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

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import _utilities
from . import outputs

__all__ = [
    'CloudCredentialAmazonec2CredentialConfig',
    'CloudCredentialAzureCredentialConfig',
    'CloudCredentialDigitaloceanCredentialConfig',
    'CloudCredentialGoogleCredentialConfig',
    'CloudCredentialHarvesterCredentialConfig',
    'CloudCredentialLinodeCredentialConfig',
    'CloudCredentialOpenstackCredentialConfig',
    'CloudCredentialS3CredentialConfig',
    'CloudCredentialVsphereCredentialConfig',
    'ClusterAgentEnvVar',
    'ClusterAksConfig',
    'ClusterAksConfigV2',
    'ClusterAksConfigV2NodePool',
    'ClusterAlertGroupRecipient',
    'ClusterAlertRuleEventRule',
    'ClusterAlertRuleMetricRule',
    'ClusterAlertRuleNodeRule',
    'ClusterAlertRuleSystemServiceRule',
    'ClusterClusterAgentDeploymentCustomization',
    'ClusterClusterAgentDeploymentCustomizationAppendToleration',
    'ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement',
    'ClusterClusterAuthEndpoint',
    'ClusterClusterMonitoringInput',
    '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',
    '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',
    'GlobalDnsProviderAlidnsConfig',
    'GlobalDnsProviderCloudflareConfig',
    'GlobalDnsProviderRoute53Config',
    'GlobalRoleRule',
    'MachineConfigV2Amazonec2Config',
    'MachineConfigV2AzureConfig',
    'MachineConfigV2DigitaloceanConfig',
    'MachineConfigV2HarvesterConfig',
    'MachineConfigV2LinodeConfig',
    'MachineConfigV2OpenstackConfig',
    'MachineConfigV2VsphereConfig',
    'MultiClusterAppAnswer',
    'MultiClusterAppMember',
    'MultiClusterAppTarget',
    'MultiClusterAppUpgradeStrategy',
    'MultiClusterAppUpgradeStrategyRollingUpdate',
    'NamespaceContainerResourceLimit',
    'NamespaceResourceQuota',
    'NamespaceResourceQuotaLimit',
    'NodePoolNodeTaint',
    'NodeTemplateAmazonec2Config',
    'NodeTemplateAzureConfig',
    'NodeTemplateDigitaloceanConfig',
    'NodeTemplateHarvesterConfig',
    'NodeTemplateHetznerConfig',
    'NodeTemplateLinodeConfig',
    'NodeTemplateNodeTaint',
    'NodeTemplateOpennebulaConfig',
    'NodeTemplateOpenstackConfig',
    'NodeTemplateOutscaleConfig',
    'NodeTemplateVsphereConfig',
    'NotifierDingtalkConfig',
    'NotifierMsteamsConfig',
    'NotifierPagerdutyConfig',
    'NotifierSlackConfig',
    'NotifierSmtpConfig',
    'NotifierWebhookConfig',
    'NotifierWechatConfig',
    'PodSecurityAdmissionConfigurationTemplateDefaults',
    'PodSecurityAdmissionConfigurationTemplateExemptions',
    'PodSecurityPolicyTemplateAllowedCsiDriver',
    'PodSecurityPolicyTemplateAllowedFlexVolume',
    'PodSecurityPolicyTemplateAllowedHostPath',
    'PodSecurityPolicyTemplateFsGroup',
    'PodSecurityPolicyTemplateFsGroupRange',
    'PodSecurityPolicyTemplateHostPort',
    'PodSecurityPolicyTemplateRunAsGroup',
    'PodSecurityPolicyTemplateRunAsGroupRange',
    'PodSecurityPolicyTemplateRunAsUser',
    'PodSecurityPolicyTemplateRunAsUserRange',
    'PodSecurityPolicyTemplateRuntimeClass',
    'PodSecurityPolicyTemplateSeLinux',
    'PodSecurityPolicyTemplateSeLinuxSeLinuxOption',
    'PodSecurityPolicyTemplateSupplementalGroup',
    'PodSecurityPolicyTemplateSupplementalGroupRange',
    'ProjectAlertGroupRecipient',
    'ProjectAlertRuleMetricRule',
    'ProjectAlertRulePodRule',
    'ProjectAlertRuleWorkloadRule',
    'ProjectContainerResourceLimit',
    'ProjectProjectMonitoringInput',
    'ProjectResourceQuota',
    'ProjectResourceQuotaNamespaceDefaultLimit',
    'ProjectResourceQuotaProjectLimit',
    'RegistryRegistry',
    'RoleTemplateRule',
    'GetClusterAksConfigResult',
    'GetClusterAksConfigV2Result',
    'GetClusterAksConfigV2NodePoolResult',
    'GetClusterAlertGroupRecipientResult',
    'GetClusterAlertRuleEventRuleResult',
    'GetClusterAlertRuleMetricRuleResult',
    'GetClusterAlertRuleNodeRuleResult',
    'GetClusterAlertRuleSystemServiceRuleResult',
    'GetClusterClusterAuthEndpointResult',
    'GetClusterClusterMonitoringInputResult',
    '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',
    'GetGlobalDnsProviderAlidnsConfigResult',
    'GetGlobalDnsProviderCloudflareConfigResult',
    'GetGlobalDnsProviderRoute53ConfigResult',
    'GetGlobalRoleRuleResult',
    'GetMultiClusterAppAnswerResult',
    'GetMultiClusterAppMemberResult',
    'GetMultiClusterAppTargetResult',
    'GetMultiClusterAppUpgradeStrategyResult',
    'GetMultiClusterAppUpgradeStrategyRollingUpdateResult',
    'GetNamespaceContainerResourceLimitResult',
    'GetNamespaceResourceQuotaResult',
    'GetNamespaceResourceQuotaLimitResult',
    'GetNodePoolNodeTaintResult',
    'GetNodeTemplateNodeTaintResult',
    'GetNotifierDingtalkConfigResult',
    'GetNotifierMsteamsConfigResult',
    'GetNotifierPagerdutyConfigResult',
    'GetNotifierSlackConfigResult',
    'GetNotifierSmtpConfigResult',
    'GetNotifierWebhookConfigResult',
    'GetNotifierWechatConfigResult',
    'GetPodSecurityAdmissionConfigurationTemplateDefaultsResult',
    'GetPodSecurityAdmissionConfigurationTemplateExemptionsResult',
    'GetPodSecurityPolicyTemplateAllowedCsiDriverResult',
    'GetPodSecurityPolicyTemplateAllowedFlexVolumeResult',
    'GetPodSecurityPolicyTemplateAllowedHostPathResult',
    'GetPodSecurityPolicyTemplateFsGroupResult',
    'GetPodSecurityPolicyTemplateFsGroupRangeResult',
    'GetPodSecurityPolicyTemplateHostPortResult',
    'GetPodSecurityPolicyTemplateRunAsGroupResult',
    'GetPodSecurityPolicyTemplateRunAsGroupRangeResult',
    'GetPodSecurityPolicyTemplateRunAsUserResult',
    'GetPodSecurityPolicyTemplateRunAsUserRangeResult',
    'GetPodSecurityPolicyTemplateRuntimeClassResult',
    'GetPodSecurityPolicyTemplateSeLinuxResult',
    'GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult',
    'GetPodSecurityPolicyTemplateSupplementalGroupResult',
    'GetPodSecurityPolicyTemplateSupplementalGroupRangeResult',
    'GetProjectAlertGroupRecipientResult',
    'GetProjectAlertRuleMetricRuleResult',
    'GetProjectAlertRulePodRuleResult',
    'GetProjectAlertRuleWorkloadRuleResult',
    'GetProjectContainerResourceLimitResult',
    'GetProjectResourceQuotaResult',
    'GetProjectResourceQuotaNamespaceDefaultLimitResult',
    'GetProjectResourceQuotaProjectLimitResult',
    'GetRegistryRegistryResult',
    'GetRoleTemplateRuleResult',
]

@pulumi.output_type
class CloudCredentialAmazonec2CredentialConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "defaultRegion":
            suggest = "default_region"

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

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

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

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 default_region: Optional[str] = None):
        """
        :param str access_key: AWS Access Key
        :param str secret_key: AWS Secret Key
        :param 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) -> str:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

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

    @property
    @pulumi.getter(name="defaultRegion")
    def default_region(self) -> Optional[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: str,
                 client_secret: str,
                 subscription_id: str,
                 environment: Optional[str] = None,
                 tenant_id: Optional[str] = None):
        """
        :param str client_id: Azure Service Principal Account ID
        :param str client_secret: Azure Service Principal Account password
        :param str subscription_id: Azure Subscription ID
        :param str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param 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) -> str:
        """
        Azure Service Principal Account ID
        """
        return pulumi.get(self, "client_id")

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

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

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

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

    @property
    @pulumi.getter(name="accessToken")
    def access_token(self) -> 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: str):
        """
        :param 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) -> 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: str,
                 kubeconfig_content: str,
                 cluster_id: Optional[str] = None):
        """
        :param str cluster_type: Harvester cluster type. must be imported or external
        :param str kubeconfig_content: Harvester cluster kubeconfig content
        :param 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) -> str:
        """
        Harvester cluster type. must be imported or external
        """
        return pulumi.get(self, "cluster_type")

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

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


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

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


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

    @property
    @pulumi.getter
    def password(self) -> 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: str,
                 secret_key: str,
                 default_bucket: Optional[str] = None,
                 default_endpoint: Optional[str] = None,
                 default_endpoint_ca: Optional[str] = None,
                 default_folder: Optional[str] = None,
                 default_region: Optional[str] = None,
                 default_skip_ssl_verify: Optional[bool] = None):
        """
        :param str access_key: AWS Access Key
        :param str secret_key: AWS Secret Key
        :param str default_bucket: AWS default bucket
        :param str default_endpoint: AWS default endpoint
        :param str default_endpoint_ca: AWS default endpoint CA
        :param str default_folder: AWS default folder
        :param str default_region: AWS default region
        :param 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) -> str:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="defaultSkipSslVerify")
    def default_skip_ssl_verify(self) -> Optional[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: str,
                 username: str,
                 vcenter: str,
                 vcenter_port: Optional[str] = None):
        """
        :param str password: vSphere password
        :param str username: vSphere username
        :param str vcenter: vSphere IP/hostname for vCenter
        :param 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) -> str:
        """
        vSphere password
        """
        return pulumi.get(self, "password")

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

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

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


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

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

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


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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> 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) -> 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) -> 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) -> str:
        """
        Subscription credentials which uniquely identify Microsoft Azure subscription
        """
        return pulumi.get(self, "subscription_id")

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

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> 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) -> 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[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[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[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[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[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[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[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[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[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[str]:
        """
        Different authentication API url to use
        """
        return pulumi.get(self, "auth_base_url")

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

    @property
    @pulumi.getter
    def count(self) -> Optional[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[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[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[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[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[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[str]:
        """
        Azure Kubernetes cluster location
        """
        return pulumi.get(self, "location")

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

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

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[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[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[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[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[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
    def tag(self) -> Optional[Mapping[str, Any]]:
        """
        Tags for Kubernetes cluster. For example, foo=bar
        """
        warnings.warn("""Use tags argument instead as []string""", DeprecationWarning)
        pulumi.log.warn("""tag is deprecated: Use tags argument instead as []string""")

        return pulumi.get(self, "tag")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[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 == "privateCluster":
            suggest = "private_cluster"
        elif key == "virtualNetwork":
            suggest = "virtual_network"
        elif key == "virtualNetworkResourceGroup":
            suggest = "virtual_network_resource_group"

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="dnsPrefix")
    def dns_prefix(self) -> Optional[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[bool]:
        """
        Enable AKS http application routing?
        """
        return pulumi.get(self, "http_application_routing")

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

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[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[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[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[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[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[str]:
        """
        The AKS log analytics workspace name
        """
        return pulumi.get(self, "log_analytics_workspace_name")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="networkServiceCidr")
    def network_service_cidr(self) -> Optional[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="privateCluster")
    def private_cluster(self) -> Optional[bool]:
        """
        Is AKS cluster private?
        """
        return pulumi.get(self, "private_cluster")

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> Optional[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[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[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[str]:
        """
        Enable AKS node pool os type
        """
        return pulumi.get(self, "os_type")

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

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


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

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

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

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

    def __init__(__self__, *,
                 notifier_id: str,
                 default_recipient: Optional[bool] = None,
                 notifier_type: Optional[str] = None,
                 recipient: Optional[str] = None):
        """
        :param str notifier_id: Recipient notifier ID
        :param bool default_recipient: Use notifier default recipient
        :param str notifier_type: Recipient notifier type
        :param str recipient: Recipient
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 resource_kind: str,
                 event_type: Optional[str] = None):
        """
        :param str resource_kind: Resource kind
        :param str event_type: Event type
        """
        pulumi.set(__self__, "resource_kind", resource_kind)
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

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

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


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

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

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

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

    def __init__(__self__, *,
                 duration: str,
                 expression: str,
                 threshold_value: float,
                 comparison: Optional[str] = None,
                 description: Optional[str] = None):
        """
        :param str duration: Metric rule duration
        :param str expression: Metric rule expression
        :param float threshold_value: Metric rule threshold value
        :param str comparison: Metric rule comparison
        :param str description: Metric rule description
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 cpu_threshold: Optional[int] = None,
                 mem_threshold: Optional[int] = None,
                 node_id: Optional[str] = None,
                 selector: Optional[Mapping[str, Any]] = None):
        """
        :param str condition: Node rule condition
        :param int cpu_threshold: Node rule cpu threshold
        :param int mem_threshold: Node rule mem threshold
        :param str node_id: Node ID
        :param Mapping[str, Any] selector: Node rule selector
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if cpu_threshold is not None:
            pulumi.set(__self__, "cpu_threshold", cpu_threshold)
        if mem_threshold is not None:
            pulumi.set(__self__, "mem_threshold", mem_threshold)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)

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

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

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

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

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


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

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


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

        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[str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterClusterAgentDeploymentCustomizationOverrideResourceRequirement']] = None):
        """
        :param Sequence['ClusterClusterAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param 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
        """
        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.ClusterClusterAgentDeploymentCustomizationAppendToleration']]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

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


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

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

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

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

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

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


@pulumi.output_type
class 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[str] = None,
                 cpu_request: Optional[str] = None,
                 memory_limit: Optional[str] = None,
                 memory_request: Optional[str] = None):
        """
        :param str cpu_limit: The maximum CPU limit for agent
        :param str cpu_request: The minimum CPU required for agent
        :param str memory_limit: The maximum memory limit for agent
        :param 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[str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

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

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

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


@pulumi.output_type
class ClusterClusterMonitoringInput(dict):
    def __init__(__self__, *,
                 answers: Optional[Mapping[str, Any]] = None,
                 version: Optional[str] = None):
        """
        :param Mapping[str, Any] answers: Answers for monitor input
        :param str version: Monitoring version
        """
        if answers is not None:
            pulumi.set(__self__, "answers", answers)
        if version is not None:
            pulumi.set(__self__, "version", version)

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

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


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

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

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

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

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, Any]] = None,
                 cluster_id: Optional[str] = None,
                 command: Optional[str] = None,
                 id: Optional[str] = None,
                 insecure_command: Optional[str] = None,
                 insecure_node_command: Optional[str] = None,
                 insecure_windows_node_command: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 manifest_url: Optional[str] = None,
                 name: Optional[str] = None,
                 node_command: Optional[str] = None,
                 token: Optional[str] = None,
                 windows_node_command: Optional[str] = None):
        """
        :param Mapping[str, Any] annotations: Annotations for the Cluster (map)
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: Labels for the Cluster (map)
        :param str name: The name of the Cluster (string)
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if insecure_command is not None:
            pulumi.set(__self__, "insecure_command", insecure_command)
        if insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 cluster_id: Optional[str] = None,
                 project_id: Optional[str] = None,
                 values: Optional[Mapping[str, Any]] = None):
        """
        :param str cluster_id: Cluster ID for answer
        :param str project_id: Project ID for answer
        :param Mapping[str, Any] values: Key/values for answer
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if values is not None:
            pulumi.set(__self__, "values", values)

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

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

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


@pulumi.output_type
class ClusterClusterTemplateQuestion(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        """
        :param str default: Default variable value
        :param str variable: Variable name
        :param bool required: Required variable
        :param 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) -> str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

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

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

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

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

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

    @property
    @pulumi.getter
    def ami(self) -> Optional[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[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[int]:
        """
        The desired number of worker nodes
        """
        return pulumi.get(self, "desired_nodes")

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def name(self) -> Optional[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[bool]:
        """
        The EKS cluster has private access
        """
        return pulumi.get(self, "private_access")

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[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[str]]:
        """
        The EKS cluster public access sources
        """
        return pulumi.get(self, "public_access_sources")

    @property
    @pulumi.getter
    def region(self) -> Optional[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[bool]:
        """
        Enable EKS cluster secret encryption
        """
        return pulumi.get(self, "secrets_encryption")

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        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[int]:
        """
        The EKS node group maximum size
        """
        return pulumi.get(self, "max_size")

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

    @property
    @pulumi.getter(name="nodeRole")
    def node_role(self) -> Optional[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[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, Any]]:
        """
        The EKS node group resource tags
        """
        return pulumi.get(self, "resource_tags")

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

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

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

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

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


@pulumi.output_type
class ClusterEksConfigV2NodeGroupLaunchTemplate(dict):
    def __init__(__self__, *,
                 id: str,
                 name: Optional[str] = None,
                 version: Optional[int] = None):
        """
        :param str id: (Computed) The ID of the resource (string)
        :param str name: The name of the Cluster (string)
        :param 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) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def version(self) -> Optional[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[str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterFleetAgentDeploymentCustomizationOverrideResourceRequirement']] = None):
        """
        :param Sequence['ClusterFleetAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param 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[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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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


@pulumi.output_type
class 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[str] = None,
                 cpu_request: Optional[str] = None,
                 memory_limit: Optional[str] = None,
                 memory_request: Optional[str] = None):
        """
        :param str cpu_limit: The maximum CPU limit for agent
        :param str cpu_request: The minimum CPU required for agent
        :param str memory_limit: The maximum memory limit for agent
        :param 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[str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

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

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

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

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

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

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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[str]:
        """
        Locations to use for the cluster
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> 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) -> 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) -> 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) -> str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "master_version")

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

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

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> 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[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) -> 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) -> 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) -> str:
        """
        The sub-network to use for the cluster
        """
        return pulumi.get(self, "sub_network")

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

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[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[bool]:
        """
        To enable kubernetes alpha feature
        """
        return pulumi.get(self, "enable_alpha_feature")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[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[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[bool]:
        """
        Enable nodepool autoscaling
        """
        return pulumi.get(self, "enable_nodepool_autoscaling")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[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[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[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[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[int]:
        """
        The number of nodes to create in this cluster
        """
        return pulumi.get(self, "node_count")

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

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

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

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> 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[str]:
        """
        The GKE ip v4 cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

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

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

    @property
    @pulumi.getter
    def imported(self) -> Optional[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[str]:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

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

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

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

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

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

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> Optional[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[str]:
        """
        The GKE cluster region. Required if `zone` is empty
        """
        return pulumi.get(self, "region")

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

    @property
    @pulumi.getter
    def zone(self) -> Optional[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[bool] = None,
                 http_load_balancing: Optional[bool] = None,
                 network_policy_config: Optional[bool] = None):
        """
        :param bool horizontal_pod_autoscaling: Enable GKE horizontal pod autoscaling
        :param bool http_load_balancing: Enable GKE HTTP load balancing
        :param 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[bool]:
        """
        Enable GKE horizontal pod autoscaling
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

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

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> Optional[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[str] = None,
                 cluster_secondary_range_name: Optional[str] = None,
                 create_subnetwork: Optional[bool] = None,
                 node_ipv4_cidr_block: Optional[str] = None,
                 services_ipv4_cidr_block: Optional[str] = None,
                 services_secondary_range_name: Optional[str] = None,
                 subnetwork_name: Optional[str] = None,
                 use_ip_aliases: Optional[bool] = None):
        """
        :param str cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block
        :param str cluster_secondary_range_name: The GKE cluster ip v4 allocation secondary range name
        :param bool create_subnetwork: Create GKE subnetwork?
        :param str node_ipv4_cidr_block: The GKE node ip v4 allocation cidr block
        :param str services_ipv4_cidr_block: The GKE services ip v4 allocation cidr block
        :param str services_secondary_range_name: The GKE services ip v4 allocation secondary range name
        :param str subnetwork_name: The GKE cluster subnetwork name
        :param 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[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[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[bool]:
        """
        Create GKE subnetwork?
        """
        return pulumi.get(self, "create_subnetwork")

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

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

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

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

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> Optional[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[bool] = None):
        """
        :param Sequence['ClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs'] cidr_blocks: The GKE master authorized network config cidr blocks
        :param 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[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: str,
                 display_name: Optional[str] = None):
        """
        :param str cidr_block: The GKE master authorized network config cidr block
        :param 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) -> 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[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: int,
                 name: str,
                 version: str,
                 autoscaling: Optional['outputs.ClusterGkeConfigV2NodePoolAutoscaling'] = None,
                 config: Optional['outputs.ClusterGkeConfigV2NodePoolConfig'] = None,
                 management: Optional['outputs.ClusterGkeConfigV2NodePoolManagement'] = None,
                 max_pods_constraint: Optional[int] = None):
        """
        :param int initial_node_count: The GKE node pool config initial node count
        :param str name: The name of the Cluster (string)
        :param 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 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) -> int:
        """
        The GKE node pool config initial node count
        """
        return pulumi.get(self, "initial_node_count")

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

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        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[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[bool] = None,
                 max_node_count: Optional[int] = None,
                 min_node_count: Optional[int] = None):
        """
        :param bool enabled: Enable GKE node pool config autoscaling
        :param int max_node_count: The GKE node pool config max node count
        :param 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[bool]:
        """
        Enable GKE node pool config autoscaling
        """
        return pulumi.get(self, "enabled")

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[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: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 auto_repair: Optional[bool] = None,
                 auto_upgrade: Optional[bool] = None):
        """
        :param bool auto_repair: Enable GKE node pool config management auto repair
        :param 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[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[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: str,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None):
        """
        :param str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block
        :param bool enable_private_endpoint: Enable GKE cluster private endpoint
        :param 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) -> 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[bool]:
        """
        Enable GKE cluster private endpoint
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[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[str] = None):
        """
        :param 'ClusterK3sConfigUpgradeStrategyArgs' upgrade_strategy: The K3S upgrade strategy
        :param 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[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[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[int] = None,
                 worker_concurrency: Optional[int] = None):
        """
        :param bool drain_server_nodes: Drain server nodes
        :param bool drain_worker_nodes: Drain worker nodes
        :param int server_concurrency: Server concurrency
        :param 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[bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

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

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

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

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

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

    @property
    @pulumi.getter
    def region(self) -> 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) -> 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) -> 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[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[str]:
        """
        The description for Cluster (string)
        """
        return pulumi.get(self, "description")

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

    @property
    @pulumi.getter(name="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[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[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[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[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[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[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[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[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[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[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[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[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[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[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[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[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[bool]:
        """
        Whether to skip deleting VCN
        """
        return pulumi.get(self, "skip_vcn_delete")

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

    @property
    @pulumi.getter(name="vcnName")
    def vcn_name(self) -> Optional[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[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[str] = None):
        """
        :param 'ClusterRke2ConfigUpgradeStrategyArgs' upgrade_strategy: The RKE2 upgrade strategy
        :param 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[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[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[int] = None,
                 worker_concurrency: Optional[int] = None):
        """
        :param bool drain_server_nodes: Drain server nodes
        :param bool drain_worker_nodes: Drain worker nodes
        :param int server_concurrency: Server concurrency
        :param 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[bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

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

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

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[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[int] = None,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 authentication: Optional['outputs.ClusterRkeConfigAuthentication'] = None,
                 authorization: Optional['outputs.ClusterRkeConfigAuthorization'] = None,
                 bastion_host: Optional['outputs.ClusterRkeConfigBastionHost'] = None,
                 cloud_provider: Optional['outputs.ClusterRkeConfigCloudProvider'] = None,
                 dns: Optional['outputs.ClusterRkeConfigDns'] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 ingress: Optional['outputs.ClusterRkeConfigIngress'] = None,
                 kubernetes_version: Optional[str] = None,
                 monitoring: Optional['outputs.ClusterRkeConfigMonitoring'] = None,
                 network: Optional['outputs.ClusterRkeConfigNetwork'] = None,
                 nodes: Optional[Sequence['outputs.ClusterRkeConfigNode']] = None,
                 prefix_path: Optional[str] = None,
                 private_registries: Optional[Sequence['outputs.ClusterRkeConfigPrivateRegistry']] = None,
                 services: Optional['outputs.ClusterRkeConfigServices'] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_cert_path: Optional[str] = None,
                 ssh_key_path: Optional[str] = None,
                 upgrade_strategy: Optional['outputs.ClusterRkeConfigUpgradeStrategy'] = None,
                 win_prefix_path: Optional[str] = None):
        """
        :param int addon_job_timeout: Optional duration in seconds of addon job.
        :param str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[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 bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param bool ignore_docker_version: Optional ignore docker version on nodes
        :param 'ClusterRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param 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 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 bool ssh_agent_auth: Optional use ssh agent auth
        :param str ssh_cert_path: Optional cluster level SSH certificate path
        :param str ssh_key_path: Optional cluster level SSH private key path
        :param 'ClusterRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param 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[int]:
        """
        Optional duration in seconds of addon job.
        """
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def addons(self) -> Optional[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[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']:
        return pulumi.get(self, "cloud_provider")

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

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

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[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[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[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[bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> Optional[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[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[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[str]] = None,
                 strategy: Optional[str] = None):
        if sans is not None:
            pulumi.set(__self__, "sans", sans)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

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

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


@pulumi.output_type
class ClusterRkeConfigAuthorization(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None,
                 options: Optional[Mapping[str, Any]] = None):
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if options is not None:
            pulumi.set(__self__, "options", options)

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

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


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

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

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

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

    def __init__(__self__, *,
                 address: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 aws_cloud_provider: Optional['outputs.ClusterRkeConfigCloudProviderAwsCloudProvider'] = None,
                 azure_cloud_provider: Optional['outputs.ClusterRkeConfigCloudProviderAzureCloudProvider'] = None,
                 custom_cloud_provider: Optional[str] = None,
                 name: Optional[str] = None,
                 openstack_cloud_provider: Optional['outputs.ClusterRkeConfigCloudProviderOpenstackCloudProvider'] = None,
                 vsphere_cloud_provider: Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProvider'] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

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

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

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

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

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

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.ClusterRkeConfigCloudProviderVsphereCloudProvider']:
        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):
        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']:
        return pulumi.get(self, "global_")

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


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

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

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

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

    def __init__(__self__, *,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None,
                 elb_security_group: Optional[str] = None,
                 kubernetes_cluster_id: Optional[str] = None,
                 kubernetes_cluster_tag: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 route_table_id: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 vpc: Optional[str] = None,
                 zone: Optional[str] = None):
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)
        if elb_security_group is not None:
            pulumi.set(__self__, "elb_security_group", elb_security_group)
        if kubernetes_cluster_id is not None:
            pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        if kubernetes_cluster_tag is not None:
            pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if route_table_id is not None:
            pulumi.set(__self__, "route_table_id", route_table_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 service: str,
                 region: Optional[str] = None,
                 signing_method: Optional[str] = None,
                 signing_name: Optional[str] = None,
                 signing_region: Optional[str] = None,
                 url: Optional[str] = None):
        pulumi.set(__self__, "service", service)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if signing_method is not None:
            pulumi.set(__self__, "signing_method", signing_method)
        if signing_name is not None:
            pulumi.set(__self__, "signing_name", signing_name)
        if signing_region is not None:
            pulumi.set(__self__, "signing_region", signing_region)
        if url is not None:
            pulumi.set(__self__, "url", url)

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 aad_client_id: str,
                 aad_client_secret: str,
                 subscription_id: str,
                 tenant_id: str,
                 aad_client_cert_password: Optional[str] = None,
                 aad_client_cert_path: Optional[str] = None,
                 cloud: Optional[str] = None,
                 cloud_provider_backoff: Optional[bool] = None,
                 cloud_provider_backoff_duration: Optional[int] = None,
                 cloud_provider_backoff_exponent: Optional[int] = None,
                 cloud_provider_backoff_jitter: Optional[int] = None,
                 cloud_provider_backoff_retries: Optional[int] = None,
                 cloud_provider_rate_limit: Optional[bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[int] = None,
                 cloud_provider_rate_limit_qps: Optional[int] = None,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 maximum_load_balancer_rule_count: Optional[int] = None,
                 primary_availability_set_name: Optional[str] = None,
                 primary_scale_set_name: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 route_table_name: Optional[str] = None,
                 security_group_name: Optional[str] = None,
                 subnet_name: Optional[str] = None,
                 use_instance_metadata: Optional[bool] = None,
                 use_managed_identity_extension: Optional[bool] = None,
                 vm_type: Optional[str] = None,
                 vnet_name: Optional[str] = None,
                 vnet_resource_group: Optional[str] = None):
        """
        :param str 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) -> str:
        return pulumi.get(self, "aad_client_id")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class 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):
        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':
        return pulumi.get(self, "global_")

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 bs_version: Optional[str] = None,
                 ignore_volume_az: Optional[bool] = None,
                 trust_device_path: Optional[bool] = None):
        if bs_version is not None:
            pulumi.set(__self__, "bs_version", bs_version)
        if ignore_volume_az is not None:
            pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        if trust_device_path is not None:
            pulumi.set(__self__, "trust_device_path", trust_device_path)

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 auth_url: str,
                 password: str,
                 username: str,
                 ca_file: Optional[str] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 region: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 trust_id: Optional[str] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if ca_file is not None:
            pulumi.set(__self__, "ca_file", ca_file)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if trust_id is not None:
            pulumi.set(__self__, "trust_id", trust_id)

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 create_monitor: Optional[bool] = None,
                 floating_network_id: Optional[str] = None,
                 lb_method: Optional[str] = None,
                 lb_provider: Optional[str] = None,
                 lb_version: Optional[str] = None,
                 manage_security_groups: Optional[bool] = None,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[int] = None,
                 monitor_timeout: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 use_octavia: Optional[bool] = None):
        if create_monitor is not None:
            pulumi.set(__self__, "create_monitor", create_monitor)
        if floating_network_id is not None:
            pulumi.set(__self__, "floating_network_id", floating_network_id)
        if lb_method is not None:
            pulumi.set(__self__, "lb_method", lb_method)
        if lb_provider is not None:
            pulumi.set(__self__, "lb_provider", lb_provider)
        if lb_version is not None:
            pulumi.set(__self__, "lb_version", lb_version)
        if manage_security_groups is not None:
            pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if use_octavia is not None:
            pulumi.set(__self__, "use_octavia", use_octavia)

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 request_timeout: Optional[int] = None,
                 search_order: Optional[str] = None):
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if search_order is not None:
            pulumi.set(__self__, "search_order", search_order)

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

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


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

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

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

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

    def __init__(__self__, *,
                 router_id: Optional[str] = None):
        if router_id is not None:
            pulumi.set(__self__, "router_id", router_id)

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


@pulumi.output_type
class 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):
        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']:
        return pulumi.get(self, "virtual_centers")

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 scsi_controller_type: Optional[str] = None):
        if scsi_controller_type is not None:
            pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

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


@pulumi.output_type
class 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[str] = None,
                 graceful_shutdown_timeout: Optional[str] = None,
                 insecure_flag: Optional[bool] = None,
                 password: Optional[str] = None,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = None,
                 user: Optional[str] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if 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[str]:
        return pulumi.get(self, "datacenters")

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 public_network: Optional[str] = None):
        if public_network is not None:
            pulumi.set(__self__, "public_network", public_network)

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


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

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

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

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

    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 user: str,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 datacenter: str,
                 folder: str,
                 server: str,
                 default_datastore: Optional[str] = None,
                 resourcepool_path: Optional[str] = None):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "server", server)
        if default_datastore is not None:
            pulumi.set(__self__, "default_datastore", default_datastore)
        if resourcepool_path is not None:
            pulumi.set(__self__, "resourcepool_path", resourcepool_path)

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 linear_autoscaler_params: Optional['outputs.ClusterRkeConfigDnsLinearAutoscalerParams'] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[Sequence[str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[str]] = None):
        """
        :param 'ClusterRkeConfigDnsLinearAutoscalerParamsArgs' linear_autoscaler_params: Linear Autoscaler Params
        :param 'ClusterRkeConfigDnsNodelocalArgs' nodelocal: Nodelocal dns
        :param Sequence['ClusterRkeConfigDnsTolerationArgs'] tolerations: DNS service tolerations
        :param 'ClusterRkeConfigDnsUpdateStrategyArgs' update_strategy: Update deployment strategy
        """
        if linear_autoscaler_params is not None:
            pulumi.set(__self__, "linear_autoscaler_params", linear_autoscaler_params)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)
        if nodelocal is not None:
            pulumi.set(__self__, "nodelocal", nodelocal)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if provider is not None:
            pulumi.set(__self__, "provider", provider)
        if reverse_cidrs is not None:
            pulumi.set(__self__, "reverse_cidrs", reverse_cidrs)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if update_strategy is not None:
            pulumi.set(__self__, "update_strategy", update_strategy)
        if upstream_nameservers is not None:
            pulumi.set(__self__, "upstream_nameservers", upstream_nameservers)

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

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

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

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

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

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.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[str]]:
        return pulumi.get(self, "upstream_nameservers")


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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

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

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


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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigDnsUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[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[bool] = None,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 http_port: Optional[int] = None,
                 https_port: Optional[int] = None,
                 network_mode: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigIngressUpdateStrategy'] = None):
        """
        :param 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[bool]:
        return pulumi.get(self, "default_backend")

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigIngressUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None):
        """
        :param 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[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, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigMonitoringToleration']] = None,
                 update_strategy: Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategy'] = None):
        """
        :param 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, Any]]:
        return pulumi.get(self, "node_selector")

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

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

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

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterRkeConfigMonitoringUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[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[int] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterRkeConfigNetworkToleration']] = None,
                 weave_network_provider: Optional['outputs.ClusterRkeConfigNetworkWeaveNetworkProvider'] = None):
        """
        :param Sequence['ClusterRkeConfigNetworkTolerationArgs'] tolerations: Network add-on tolerations
        """
        if aci_network_provider is not None:
            pulumi.set(__self__, "aci_network_provider", aci_network_provider)
        if calico_network_provider is not None:
            pulumi.set(__self__, "calico_network_provider", calico_network_provider)
        if canal_network_provider is not None:
            pulumi.set(__self__, "canal_network_provider", canal_network_provider)
        if flannel_network_provider is not None:
            pulumi.set(__self__, "flannel_network_provider", flannel_network_provider)
        if mtu is not None:
            pulumi.set(__self__, "mtu", mtu)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if plugin is not None:
            pulumi.set(__self__, "plugin", plugin)
        if tolerations is not None:
            pulumi.set(__self__, "tolerations", tolerations)
        if weave_network_provider is not None:
            pulumi.set(__self__, "weave_network_provider", weave_network_provider)

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

    @property
    @pulumi.getter(name="calicoNetworkProvider")
    def calico_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkCalicoNetworkProvider']:
        return pulumi.get(self, "calico_network_provider")

    @property
    @pulumi.getter(name="canalNetworkProvider")
    def canal_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkCanalNetworkProvider']:
        return pulumi.get(self, "canal_network_provider")

    @property
    @pulumi.getter(name="flannelNetworkProvider")
    def flannel_network_provider(self) -> Optional['outputs.ClusterRkeConfigNetworkFlannelNetworkProvider']:
        return pulumi.get(self, "flannel_network_provider")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[str]:
        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[str] = None):
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)

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


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

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


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

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


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

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

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

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

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

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


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

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


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

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

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

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

    def __init__(__self__, *,
                 address: str,
                 roles: Sequence[str],
                 user: str,
                 docker_socket: Optional[str] = None,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        """
        :param Mapping[str, Any] labels: Labels for the Cluster (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.ClusterRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param 'ClusterRkeConfigPrivateRegistryEcrCredentialPluginArgs' ecr_credential_plugin: ECR credential plugin config
        """
        pulumi.set(__self__, "url", url)
        if ecr_credential_plugin is not None:
            pulumi.set(__self__, "ecr_credential_plugin", ecr_credential_plugin)
        if is_default is not None:
            pulumi.set(__self__, "is_default", is_default)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

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

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

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


@pulumi.output_type
class 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):
        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']:
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApi']:
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional['outputs.ClusterRkeConfigServicesKubeController']:
        return pulumi.get(self, "kube_controller")

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfig'] = None,
                 ca_cert: Optional[str] = None,
                 cert: Optional[str] = None,
                 creation: Optional[str] = None,
                 external_urls: Optional[Sequence[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[int] = None):
        """
        :param str ca_cert: (Computed/Sensitive) K8s cluster ca cert (string)
        """
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfig']:
        return pulumi.get(self, "backup_config")

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

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

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.ClusterRkeConfigServicesEtcdBackupConfigS3BackupConfig']:
        return pulumi.get(self, "s3_backup_config")

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

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


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

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 admission_configuration: Optional['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfiguration'] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[str] = None,
                 service_node_port_range: Optional[str] = None):
        """
        :param 'ClusterRkeConfigServicesKubeApiAdmissionConfigurationArgs' admission_configuration: Cluster admission configuration
        """
        if admission_configuration is not None:
            pulumi.set(__self__, "admission_configuration", admission_configuration)
        if always_pull_images is not None:
            pulumi.set(__self__, "always_pull_images", always_pull_images)
        if audit_log is not None:
            pulumi.set(__self__, "audit_log", audit_log)
        if event_rate_limit is not None:
            pulumi.set(__self__, "event_rate_limit", event_rate_limit)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfiguration']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

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

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLog']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiEventRateLimit']:
        return pulumi.get(self, "event_rate_limit")

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

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

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

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

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

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.ClusterRkeConfigServicesKubeApiSecretsEncryptionConfig']:
        return pulumi.get(self, "secrets_encryption_config")

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

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


@pulumi.output_type
class 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[str] = None,
                 kind: Optional[str] = None,
                 plugins: Optional[Sequence['outputs.ClusterRkeConfigServicesKubeApiAdmissionConfigurationPlugin']] = None):
        """
        :param str api_version: Admission configuration ApiVersion
        :param 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[str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[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[str] = None,
                 name: Optional[str] = None,
                 path: Optional[str] = None):
        """
        :param str configuration: Plugin configuration
        :param str name: The name of the Cluster (string)
        :param 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[str]:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

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

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


@pulumi.output_type
class ClusterRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[bool] = None):
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

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


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

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

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

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

    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = None,
                 path: Optional[str] = None,
                 policy: Optional[str] = None):
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

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

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

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

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

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

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


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

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

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


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

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

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

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

    def __init__(__self__, *,
                 custom_config: Optional[str] = None,
                 enabled: Optional[bool] = None):
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

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

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


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

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

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

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

    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None,
                 service_cluster_ip_range: Optional[str] = None):
        if cluster_cidr is not None:
            pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 fail_swap_on: Optional[bool] = None,
                 generate_serving_certificate: Optional[bool] = None,
                 image: Optional[str] = None,
                 infra_container_image: Optional[str] = None):
        if cluster_dns_server is not None:
            pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        if cluster_domain is not None:
            pulumi.set(__self__, "cluster_domain", cluster_domain)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if fail_swap_on is not None:
            pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if infra_container_image is not None:
            pulumi.set(__self__, "infra_container_image", infra_container_image)

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

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

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

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

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

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

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

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 drain: Optional[bool] = None,
                 drain_input: Optional['outputs.ClusterRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if drain_input is not None:
            pulumi.set(__self__, "drain_input", drain_input)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

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

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional['outputs.ClusterRkeConfigUpgradeStrategyDrainInput']:
        return pulumi.get(self, "drain_input")

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

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


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

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

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

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

    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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

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

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

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


@pulumi.output_type
class ClusterSyncNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "externalIpAddress":
            suggest = "external_ip_address"
        elif key == "ipAddress":
            suggest = "ip_address"
        elif key == "nodePoolId":
            suggest = "node_pool_id"
        elif key == "nodeTemplateId":
            suggest = "node_template_id"
        elif key == "providerId":
            suggest = "provider_id"
        elif key == "requestedHostname":
            suggest = "requested_hostname"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "systemInfo":
            suggest = "system_info"

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

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

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

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, Any]] = None,
                 capacity: Optional[Mapping[str, Any]] = None,
                 cluster_id: Optional[str] = None,
                 external_ip_address: Optional[str] = None,
                 hostname: Optional[str] = None,
                 id: Optional[str] = None,
                 ip_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 name: Optional[str] = None,
                 node_pool_id: Optional[str] = None,
                 node_template_id: Optional[str] = None,
                 provider_id: Optional[str] = None,
                 requested_hostname: Optional[str] = None,
                 roles: Optional[Sequence[str]] = None,
                 ssh_user: Optional[str] = None,
                 system_info: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] annotations: Annotations of the resource
        :param str cluster_id: The cluster ID that is syncing (string)
        :param str id: (Computed) The ID of the resource. Same as `cluster_id` (string)
        :param Mapping[str, Any] labels: Labels of the resource
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if capacity is not None:
            pulumi.set(__self__, "capacity", capacity)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if external_ip_address is not None:
            pulumi.set(__self__, "external_ip_address", external_ip_address)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_pool_id is not None:
            pulumi.set(__self__, "node_pool_id", node_pool_id)
        if node_template_id is not None:
            pulumi.set(__self__, "node_template_id", node_template_id)
        if provider_id is not None:
            pulumi.set(__self__, "provider_id", provider_id)
        if requested_hostname is not None:
            pulumi.set(__self__, "requested_hostname", requested_hostname)
        if roles is not None:
            pulumi.set(__self__, "roles", roles)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if system_info is not None:
            pulumi.set(__self__, "system_info", system_info)

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateMember(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessType":
            suggest = "access_type"
        elif key == "groupPrincipalId":
            suggest = "group_principal_id"
        elif key == "userPrincipalId":
            suggest = "user_principal_id"

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

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

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

    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type: member, owner, read-only
        :param str group_principal_id: Member group principal id
        :param 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[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[str]:
        """
        Member group principal id
        """
        return pulumi.get(self, "group_principal_id")

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

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

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

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

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

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

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        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 == "defaultPodSecurityPolicyTemplateId":
            suggest = "default_pod_security_policy_template_id"
        elif key == "desiredAgentImage":
            suggest = "desired_agent_image"
        elif key == "desiredAuthImage":
            suggest = "desired_auth_image"
        elif key == "dockerRootDir":
            suggest = "docker_root_dir"
        elif key == "enableClusterAlerting":
            suggest = "enable_cluster_alerting"
        elif key == "enableClusterMonitoring":
            suggest = "enable_cluster_monitoring"
        elif key == "enableNetworkPolicy":
            suggest = "enable_network_policy"
        elif key == "windowsPreferedCluster":
            suggest = "windows_prefered_cluster"

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

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

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

    def __init__(__self__, *,
                 rke_config: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfig',
                 cluster_auth_endpoint: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpoint'] = None,
                 default_cluster_role_for_project_members: Optional[str] = None,
                 default_pod_security_admission_configuration_template_name: Optional[str] = None,
                 default_pod_security_policy_template_id: Optional[str] = None,
                 desired_agent_image: Optional[str] = None,
                 desired_auth_image: Optional[str] = None,
                 docker_root_dir: Optional[str] = None,
                 enable_cluster_alerting: Optional[bool] = None,
                 enable_cluster_monitoring: Optional[bool] = None,
                 enable_network_policy: Optional[bool] = None,
                 windows_prefered_cluster: Optional[bool] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs' rke_config: Rancher Kubernetes Engine Config
        :param 'ClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs' cluster_auth_endpoint: Local cluster auth endpoint
        :param str default_cluster_role_for_project_members: Default cluster role for project members
        :param str default_pod_security_admission_configuration_template_name: Default pod security admission configuration template name
        :param str default_pod_security_policy_template_id: Default pod security policy template ID
        :param str desired_agent_image: Desired agent image
        :param str desired_auth_image: Desired auth image
        :param str docker_root_dir: Docker Root Dir
        :param bool enable_cluster_alerting: Enable built-in cluster alerting
        :param bool enable_cluster_monitoring: Enable built-in cluster monitoring
        :param bool enable_network_policy: Enable project network isolation
        :param bool windows_prefered_cluster: Windows prefered cluster
        """
        pulumi.set(__self__, "rke_config", rke_config)
        if cluster_auth_endpoint is not None:
            pulumi.set(__self__, "cluster_auth_endpoint", cluster_auth_endpoint)
        if default_cluster_role_for_project_members is not None:
            pulumi.set(__self__, "default_cluster_role_for_project_members", default_cluster_role_for_project_members)
        if default_pod_security_admission_configuration_template_name is not None:
            pulumi.set(__self__, "default_pod_security_admission_configuration_template_name", default_pod_security_admission_configuration_template_name)
        if default_pod_security_policy_template_id is not None:
            pulumi.set(__self__, "default_pod_security_policy_template_id", default_pod_security_policy_template_id)
        if desired_agent_image is not None:
            pulumi.set(__self__, "desired_agent_image", desired_agent_image)
        if desired_auth_image is not None:
            pulumi.set(__self__, "desired_auth_image", desired_auth_image)
        if docker_root_dir is not None:
            pulumi.set(__self__, "docker_root_dir", docker_root_dir)
        if enable_cluster_alerting is not None:
            pulumi.set(__self__, "enable_cluster_alerting", enable_cluster_alerting)
        if enable_cluster_monitoring is not None:
            pulumi.set(__self__, "enable_cluster_monitoring", enable_cluster_monitoring)
        if enable_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if windows_prefered_cluster is not None:
            pulumi.set(__self__, "windows_prefered_cluster", windows_prefered_cluster)

    @property
    @pulumi.getter(name="rkeConfig")
    def rke_config(self) -> '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[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[str]:
        """
        Default pod security admission configuration template name
        """
        return pulumi.get(self, "default_pod_security_admission_configuration_template_name")

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[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[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

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

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

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


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

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

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

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

    def __init__(__self__, *,
                 addon_job_timeout: Optional[int] = None,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 authentication: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthentication'] = None,
                 authorization: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization'] = None,
                 bastion_host: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHost'] = None,
                 cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider'] = None,
                 dns: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns'] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 ingress: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngress'] = None,
                 kubernetes_version: Optional[str] = None,
                 monitoring: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoring'] = None,
                 network: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetwork'] = None,
                 nodes: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode']] = None,
                 prefix_path: Optional[str] = None,
                 private_registries: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry']] = None,
                 services: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices'] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_cert_path: Optional[str] = None,
                 ssh_key_path: Optional[str] = None,
                 upgrade_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy'] = None,
                 win_prefix_path: Optional[str] = None):
        """
        :param int addon_job_timeout: Optional duration in seconds of addon job.
        :param str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[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 bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param bool ignore_docker_version: Optional ignore docker version on nodes
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressArgs' ingress: Kubernetes ingress configuration
        :param 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 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 bool ssh_agent_auth: Optional use ssh agent auth
        :param str ssh_cert_path: Optional cluster level SSH certificate path
        :param str ssh_key_path: Optional cluster level SSH private key path
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param 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[int]:
        """
        Optional duration in seconds of addon job.
        """
        return pulumi.get(self, "addon_job_timeout")

    @property
    @pulumi.getter
    def addons(self) -> Optional[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[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[bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[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[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[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[bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")

    @property
    @pulumi.getter(name="sshCertPath")
    def ssh_cert_path(self) -> Optional[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[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[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[str]] = None,
                 strategy: Optional[str] = None):
        if sans is not None:
            pulumi.set(__self__, "sans", sans)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorization(dict):
    def __init__(__self__, *,
                 mode: Optional[str] = None,
                 options: Optional[Mapping[str, Any]] = None):
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if options is not None:
            pulumi.set(__self__, "options", options)

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

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


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

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

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

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

    def __init__(__self__, *,
                 address: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

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

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

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

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

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

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


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsCloudProvider":
            suggest = "aws_cloud_provider"
        elif key == "azureCloudProvider":
            suggest = "azure_cloud_provider"
        elif key == "customCloudProvider":
            suggest = "custom_cloud_provider"
        elif key == "openstackCloudProvider":
            suggest = "openstack_cloud_provider"
        elif key == "vsphereCloudProvider":
            suggest = "vsphere_cloud_provider"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aws_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider'] = None,
                 azure_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider'] = None,
                 custom_cloud_provider: Optional[str] = None,
                 name: Optional[str] = None,
                 openstack_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider'] = None,
                 vsphere_cloud_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider'] = None):
        """
        :param str name: The cluster template name (string)
        """
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if custom_cloud_provider is not None:
            pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider']:
        return pulumi.get(self, "azure_cloud_provider")

    @property
    @pulumi.getter(name="customCloudProvider")
    def custom_cloud_provider(self) -> Optional[str]:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider']:
        return pulumi.get(self, "vsphere_cloud_provider")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "serviceOverrides":
            suggest = "service_overrides"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 global_: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal'] = None,
                 service_overrides: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride']] = None):
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal']:
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride']]:
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "disableSecurityGroupIngress":
            suggest = "disable_security_group_ingress"
        elif key == "disableStrictZoneCheck":
            suggest = "disable_strict_zone_check"
        elif key == "elbSecurityGroup":
            suggest = "elb_security_group"
        elif key == "kubernetesClusterId":
            suggest = "kubernetes_cluster_id"
        elif key == "kubernetesClusterTag":
            suggest = "kubernetes_cluster_tag"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "routeTableId":
            suggest = "route_table_id"
        elif key == "subnetId":
            suggest = "subnet_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None,
                 elb_security_group: Optional[str] = None,
                 kubernetes_cluster_id: Optional[str] = None,
                 kubernetes_cluster_tag: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 route_table_id: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 vpc: Optional[str] = None,
                 zone: Optional[str] = None):
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)
        if elb_security_group is not None:
            pulumi.set(__self__, "elb_security_group", elb_security_group)
        if kubernetes_cluster_id is not None:
            pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        if kubernetes_cluster_tag is not None:
            pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if route_table_id is not None:
            pulumi.set(__self__, "route_table_id", route_table_id)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if vpc is not None:
            pulumi.set(__self__, "vpc", vpc)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[bool]:
        return pulumi.get(self, "disable_strict_zone_check")

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> Optional[str]:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> Optional[str]:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> Optional[str]:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[str]:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> Optional[str]:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> Optional[str]:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> Optional[str]:
        return pulumi.get(self, "zone")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "signingMethod":
            suggest = "signing_method"
        elif key == "signingName":
            suggest = "signing_name"
        elif key == "signingRegion":
            suggest = "signing_region"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverride.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 service: str,
                 region: Optional[str] = None,
                 signing_method: Optional[str] = None,
                 signing_name: Optional[str] = None,
                 signing_region: Optional[str] = None,
                 url: Optional[str] = None):
        pulumi.set(__self__, "service", service)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if signing_method is not None:
            pulumi.set(__self__, "signing_method", signing_method)
        if signing_name is not None:
            pulumi.set(__self__, "signing_name", signing_name)
        if signing_region is not None:
            pulumi.set(__self__, "signing_region", signing_region)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> Optional[str]:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> Optional[str]:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> Optional[str]:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aadClientId":
            suggest = "aad_client_id"
        elif key == "aadClientSecret":
            suggest = "aad_client_secret"
        elif key == "subscriptionId":
            suggest = "subscription_id"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "aadClientCertPassword":
            suggest = "aad_client_cert_password"
        elif key == "aadClientCertPath":
            suggest = "aad_client_cert_path"
        elif key == "cloudProviderBackoff":
            suggest = "cloud_provider_backoff"
        elif key == "cloudProviderBackoffDuration":
            suggest = "cloud_provider_backoff_duration"
        elif key == "cloudProviderBackoffExponent":
            suggest = "cloud_provider_backoff_exponent"
        elif key == "cloudProviderBackoffJitter":
            suggest = "cloud_provider_backoff_jitter"
        elif key == "cloudProviderBackoffRetries":
            suggest = "cloud_provider_backoff_retries"
        elif key == "cloudProviderRateLimit":
            suggest = "cloud_provider_rate_limit"
        elif key == "cloudProviderRateLimitBucket":
            suggest = "cloud_provider_rate_limit_bucket"
        elif key == "cloudProviderRateLimitQps":
            suggest = "cloud_provider_rate_limit_qps"
        elif key == "loadBalancerSku":
            suggest = "load_balancer_sku"
        elif key == "maximumLoadBalancerRuleCount":
            suggest = "maximum_load_balancer_rule_count"
        elif key == "primaryAvailabilitySetName":
            suggest = "primary_availability_set_name"
        elif key == "primaryScaleSetName":
            suggest = "primary_scale_set_name"
        elif key == "resourceGroup":
            suggest = "resource_group"
        elif key == "routeTableName":
            suggest = "route_table_name"
        elif key == "securityGroupName":
            suggest = "security_group_name"
        elif key == "subnetName":
            suggest = "subnet_name"
        elif key == "useInstanceMetadata":
            suggest = "use_instance_metadata"
        elif key == "useManagedIdentityExtension":
            suggest = "use_managed_identity_extension"
        elif key == "vmType":
            suggest = "vm_type"
        elif key == "vnetName":
            suggest = "vnet_name"
        elif key == "vnetResourceGroup":
            suggest = "vnet_resource_group"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aad_client_id: str,
                 aad_client_secret: str,
                 subscription_id: str,
                 tenant_id: str,
                 aad_client_cert_password: Optional[str] = None,
                 aad_client_cert_path: Optional[str] = None,
                 cloud: Optional[str] = None,
                 cloud_provider_backoff: Optional[bool] = None,
                 cloud_provider_backoff_duration: Optional[int] = None,
                 cloud_provider_backoff_exponent: Optional[int] = None,
                 cloud_provider_backoff_jitter: Optional[int] = None,
                 cloud_provider_backoff_retries: Optional[int] = None,
                 cloud_provider_rate_limit: Optional[bool] = None,
                 cloud_provider_rate_limit_bucket: Optional[int] = None,
                 cloud_provider_rate_limit_qps: Optional[int] = None,
                 load_balancer_sku: Optional[str] = None,
                 location: Optional[str] = None,
                 maximum_load_balancer_rule_count: Optional[int] = None,
                 primary_availability_set_name: Optional[str] = None,
                 primary_scale_set_name: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 route_table_name: Optional[str] = None,
                 security_group_name: Optional[str] = None,
                 subnet_name: Optional[str] = None,
                 use_instance_metadata: Optional[bool] = None,
                 use_managed_identity_extension: Optional[bool] = None,
                 vm_type: Optional[str] = None,
                 vnet_name: Optional[str] = None,
                 vnet_resource_group: Optional[str] = None):
        """
        :param 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) -> str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="aadClientCertPassword")
    def aad_client_cert_password(self) -> Optional[str]:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> Optional[str]:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter
    def cloud(self) -> Optional[str]:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> Optional[bool]:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> Optional[bool]:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> Optional[int]:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        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[str]:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> Optional[int]:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> Optional[str]:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> Optional[str]:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> Optional[str]:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> Optional[str]:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> Optional[str]:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> Optional[str]:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> Optional[bool]:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> Optional[bool]:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> Optional[str]:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> Optional[str]:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> Optional[str]:
        return pulumi.get(self, "vnet_resource_group")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "global":
            suggest = "global_"
        elif key == "blockStorage":
            suggest = "block_storage"
        elif key == "loadBalancer":
            suggest = "load_balancer"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 global_: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal',
                 block_storage: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage'] = None,
                 load_balancer: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer'] = None,
                 metadata: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata'] = None,
                 route: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute'] = None):
        pulumi.set(__self__, "global_", global_)
        if block_storage is not None:
            pulumi.set(__self__, "block_storage", block_storage)
        if load_balancer is not None:
            pulumi.set(__self__, "load_balancer", load_balancer)
        if metadata is not None:
            pulumi.set(__self__, "metadata", metadata)
        if route is not None:
            pulumi.set(__self__, "route", route)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="blockStorage")
    def block_storage(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage']:
        return pulumi.get(self, "block_storage")

    @property
    @pulumi.getter(name="loadBalancer")
    def load_balancer(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer']:
        return pulumi.get(self, "load_balancer")

    @property
    @pulumi.getter
    def metadata(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata']:
        return pulumi.get(self, "metadata")

    @property
    @pulumi.getter
    def route(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute']:
        return pulumi.get(self, "route")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bsVersion":
            suggest = "bs_version"
        elif key == "ignoreVolumeAz":
            suggest = "ignore_volume_az"
        elif key == "trustDevicePath":
            suggest = "trust_device_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderBlockStorage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bs_version: Optional[str] = None,
                 ignore_volume_az: Optional[bool] = None,
                 trust_device_path: Optional[bool] = None):
        if bs_version is not None:
            pulumi.set(__self__, "bs_version", bs_version)
        if ignore_volume_az is not None:
            pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        if trust_device_path is not None:
            pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> Optional[str]:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> Optional[bool]:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "caFile":
            suggest = "ca_file"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "trustId":
            suggest = "trust_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_url: str,
                 password: str,
                 username: str,
                 ca_file: Optional[str] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 region: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 trust_id: Optional[str] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "username", username)
        if ca_file is not None:
            pulumi.set(__self__, "ca_file", ca_file)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if trust_id is not None:
            pulumi.set(__self__, "trust_id", trust_id)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> str:
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> Optional[str]:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[str]:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[str]:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[str]:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> Optional[str]:
        return pulumi.get(self, "trust_id")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "createMonitor":
            suggest = "create_monitor"
        elif key == "floatingNetworkId":
            suggest = "floating_network_id"
        elif key == "lbMethod":
            suggest = "lb_method"
        elif key == "lbProvider":
            suggest = "lb_provider"
        elif key == "lbVersion":
            suggest = "lb_version"
        elif key == "manageSecurityGroups":
            suggest = "manage_security_groups"
        elif key == "monitorDelay":
            suggest = "monitor_delay"
        elif key == "monitorMaxRetries":
            suggest = "monitor_max_retries"
        elif key == "monitorTimeout":
            suggest = "monitor_timeout"
        elif key == "subnetId":
            suggest = "subnet_id"
        elif key == "useOctavia":
            suggest = "use_octavia"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 create_monitor: Optional[bool] = None,
                 floating_network_id: Optional[str] = None,
                 lb_method: Optional[str] = None,
                 lb_provider: Optional[str] = None,
                 lb_version: Optional[str] = None,
                 manage_security_groups: Optional[bool] = None,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[int] = None,
                 monitor_timeout: Optional[str] = None,
                 subnet_id: Optional[str] = None,
                 use_octavia: Optional[bool] = None):
        if create_monitor is not None:
            pulumi.set(__self__, "create_monitor", create_monitor)
        if floating_network_id is not None:
            pulumi.set(__self__, "floating_network_id", floating_network_id)
        if lb_method is not None:
            pulumi.set(__self__, "lb_method", lb_method)
        if lb_provider is not None:
            pulumi.set(__self__, "lb_provider", lb_provider)
        if lb_version is not None:
            pulumi.set(__self__, "lb_version", lb_version)
        if manage_security_groups is not None:
            pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)
        if subnet_id is not None:
            pulumi.set(__self__, "subnet_id", subnet_id)
        if use_octavia is not None:
            pulumi.set(__self__, "use_octavia", use_octavia)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> Optional[bool]:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> Optional[str]:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> Optional[str]:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> Optional[str]:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> Optional[str]:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> Optional[bool]:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[int]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[str]:
        return pulumi.get(self, "monitor_timeout")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> Optional[str]:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> Optional[bool]:
        return pulumi.get(self, "use_octavia")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "requestTimeout":
            suggest = "request_timeout"
        elif key == "searchOrder":
            suggest = "search_order"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadata.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 request_timeout: Optional[int] = None,
                 search_order: Optional[str] = None):
        if request_timeout is not None:
            pulumi.set(__self__, "request_timeout", request_timeout)
        if search_order is not None:
            pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> Optional[int]:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> Optional[str]:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "routerId":
            suggest = "router_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRoute.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 router_id: Optional[str] = None):
        if router_id is not None:
            pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> Optional[str]:
        return pulumi.get(self, "router_id")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "virtualCenters":
            suggest = "virtual_centers"
        elif key == "global":
            suggest = "global_"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProvider.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 virtual_centers: Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter'],
                 workspace: 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace',
                 disk: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk'] = None,
                 global_: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal'] = None,
                 network: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork'] = None):
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)
        if disk is not None:
            pulumi.set(__self__, "disk", disk)
        if global_ is not None:
            pulumi.set(__self__, "global_", global_)
        if network is not None:
            pulumi.set(__self__, "network", network)

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace':
        return pulumi.get(self, "workspace")

    @property
    @pulumi.getter
    def disk(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk']:
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal']:
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork']:
        return pulumi.get(self, "network")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "scsiControllerType":
            suggest = "scsi_controller_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDisk.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 scsi_controller_type: Optional[str] = None):
        if scsi_controller_type is not None:
            pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> Optional[str]:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "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[str] = None,
                 graceful_shutdown_timeout: Optional[str] = None,
                 insecure_flag: Optional[bool] = None,
                 password: Optional[str] = None,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = None,
                 user: Optional[str] = None):
        if datacenters is not None:
            pulumi.set(__self__, "datacenters", datacenters)
        if 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[str]:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[str]:
        return pulumi.get(self, "graceful_shutdown_timeout")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> Optional[bool]:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[int]:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "publicNetwork":
            suggest = "public_network"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetwork.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 public_network: Optional[str] = None):
        if public_network is not None:
            pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> Optional[str]:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "soapRoundtripCount":
            suggest = "soap_roundtrip_count"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 user: str,
                 port: Optional[str] = None,
                 soap_roundtrip_count: Optional[int] = None):
        """
        :param str name: The cluster template name (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if soap_roundtrip_count is not None:
            pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> Optional[int]:
        return pulumi.get(self, "soap_roundtrip_count")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultDatastore":
            suggest = "default_datastore"
        elif key == "resourcepoolPath":
            suggest = "resourcepool_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspace.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 datacenter: str,
                 folder: str,
                 server: str,
                 default_datastore: Optional[str] = None,
                 resourcepool_path: Optional[str] = None):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "server", server)
        if default_datastore is not None:
            pulumi.set(__self__, "default_datastore", default_datastore)
        if resourcepool_path is not None:
            pulumi.set(__self__, "resourcepool_path", resourcepool_path)

    @property
    @pulumi.getter
    def datacenter(self) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def server(self) -> str:
        return pulumi.get(self, "server")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> Optional[str]:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> Optional[str]:
        return pulumi.get(self, "resourcepool_path")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "linearAutoscalerParams":
            suggest = "linear_autoscaler_params"
        elif key == "nodeSelector":
            suggest = "node_selector"
        elif key == "reverseCidrs":
            suggest = "reverse_cidrs"
        elif key == "updateStrategy":
            suggest = "update_strategy"
        elif key == "upstreamNameservers":
            suggest = "upstream_nameservers"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDns.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 linear_autoscaler_params: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams'] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 nodelocal: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal'] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 reverse_cidrs: Optional[Sequence[str]] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy'] = None,
                 upstream_nameservers: Optional[Sequence[str]] = None):
        """
        :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, Any]]:
        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, Any]]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration']]:
        """
        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[str]]:
        return pulumi.get(self, "upstream_nameservers")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "coresPerReplica":
            suggest = "cores_per_replica"
        elif key == "nodesPerReplica":
            suggest = "nodes_per_replica"
        elif key == "preventSinglePointFailure":
            suggest = "prevent_single_point_failure"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParams.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cores_per_replica: Optional[float] = None,
                 max: Optional[int] = None,
                 min: Optional[int] = None,
                 nodes_per_replica: Optional[float] = None,
                 prevent_single_point_failure: Optional[bool] = None):
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

    @property
    @pulumi.getter(name="coresPerReplica")
    def cores_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[int]:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[int]:
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "nodes_per_replica")

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[bool]:
        return pulumi.get(self, "prevent_single_point_failure")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ipAddress":
            suggest = "ip_address"
        elif key == "nodeSelector":
            suggest = "node_selector"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[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[bool] = None,
                 dns_policy: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 http_port: Optional[int] = None,
                 https_port: Optional[int] = None,
                 network_mode: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy'] = None):
        """
        :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[bool]:
        return pulumi.get(self, "default_backend")

    @property
    @pulumi.getter(name="dnsPolicy")
    def dns_policy(self) -> Optional[str]:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> Optional[int]:
        return pulumi.get(self, "http_port")

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> Optional[int]:
        return pulumi.get(self, "https_port")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> Optional[str]:
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressToleration']]:
        """
        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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None):
        """
        :param 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[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, Any]] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 provider: Optional[str] = None,
                 replicas: Optional[int] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration']] = None,
                 update_strategy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy'] = None):
        """
        :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, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> Optional[str]:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> Optional[int]:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringToleration']]:
        """
        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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdate'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'ClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[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[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[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[int] = None,
                 options: Optional[Mapping[str, Any]] = None,
                 plugin: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']] = None,
                 weave_network_provider: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider'] = None):
        """
        :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[int]:
        return pulumi.get(self, "mtu")

    @property
    @pulumi.getter
    def options(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> Optional[str]:
        return pulumi.get(self, "plugin")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration']]:
        """
        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: str,
                 apic_hosts: Sequence[str],
                 apic_user_crt: str,
                 apic_user_key: str,
                 apic_user_name: str,
                 encap_type: str,
                 extern_dynamic: str,
                 extern_static: str,
                 kube_api_vlan: str,
                 l3out: str,
                 l3out_external_networks: Sequence[str],
                 mcast_range_end: str,
                 mcast_range_start: str,
                 node_subnet: str,
                 node_svc_subnet: str,
                 service_vlan: str,
                 system_id: str,
                 token: str,
                 vrf_name: str,
                 vrf_tenant: str,
                 apic_refresh_ticker_adjust: Optional[str] = None,
                 apic_refresh_time: Optional[str] = None,
                 apic_subscription_delay: Optional[str] = None,
                 capic: Optional[str] = None,
                 controller_log_level: Optional[str] = None,
                 disable_periodic_snat_global_info_sync: Optional[str] = None,
                 disable_wait_for_network: Optional[str] = None,
                 drop_log_enable: Optional[str] = None,
                 duration_wait_for_network: Optional[str] = None,
                 enable_endpoint_slice: Optional[str] = None,
                 ep_registry: Optional[str] = None,
                 gbp_pod_subnet: Optional[str] = None,
                 host_agent_log_level: Optional[str] = None,
                 image_pull_policy: Optional[str] = None,
                 image_pull_secret: Optional[str] = None,
                 infra_vlan: Optional[str] = None,
                 install_istio: Optional[str] = None,
                 istio_profile: Optional[str] = None,
                 kafka_brokers: Optional[Sequence[str]] = None,
                 kafka_client_crt: Optional[str] = None,
                 kafka_client_key: Optional[str] = None,
                 max_nodes_svc_graph: Optional[str] = None,
                 mtu_head_room: Optional[str] = None,
                 multus_disable: Optional[str] = None,
                 no_priority_class: Optional[str] = None,
                 node_pod_if_enable: Optional[str] = None,
                 opflex_client_ssl: Optional[str] = None,
                 opflex_device_delete_timeout: Optional[str] = None,
                 opflex_log_level: Optional[str] = None,
                 opflex_mode: Optional[str] = None,
                 opflex_server_port: Optional[str] = None,
                 overlay_vrf_name: Optional[str] = None,
                 ovs_memory_limit: Optional[str] = None,
                 pbr_tracking_non_snat: Optional[str] = None,
                 pod_subnet_chunk_size: Optional[str] = None,
                 run_gbp_container: Optional[str] = None,
                 run_opflex_server_container: Optional[str] = None,
                 service_monitor_interval: Optional[str] = None,
                 snat_contract_scope: Optional[str] = None,
                 snat_namespace: Optional[str] = None,
                 snat_port_range_end: Optional[str] = None,
                 snat_port_range_start: Optional[str] = None,
                 snat_ports_per_node: Optional[str] = None,
                 sriov_enable: Optional[str] = None,
                 subnet_domain_name: Optional[str] = None,
                 tenant: Optional[str] = None,
                 use_aci_anywhere_crd: Optional[str] = None,
                 use_aci_cni_priority_class: Optional[str] = None,
                 use_cluster_role: Optional[str] = None,
                 use_host_netns_volume: Optional[str] = None,
                 use_opflex_server_volume: Optional[str] = None,
                 use_privileged_container: Optional[str] = None,
                 vmm_controller: Optional[str] = None,
                 vmm_domain: Optional[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) -> str:
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[str]:
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> str:
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> str:
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> str:
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> str:
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> str:
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> str:
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> str:
        return pulumi.get(self, "kube_api_vlan")

    @property
    @pulumi.getter
    def l3out(self) -> str:
        return pulumi.get(self, "l3out")

    @property
    @pulumi.getter(name="l3outExternalNetworks")
    def l3out_external_networks(self) -> Sequence[str]:
        return pulumi.get(self, "l3out_external_networks")

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> str:
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> str:
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> str:
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> str:
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> str:
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> str:
        return pulumi.get(self, "system_id")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> str:
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> str:
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[str]:
        return pulumi.get(self, "apic_subscription_delay")

    @property
    @pulumi.getter
    def capic(self) -> Optional[str]:
        return pulumi.get(self, "capic")

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[str]:
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[str]:
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[str]:
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[str]:
        return pulumi.get(self, "enable_endpoint_slice")

    @property
    @pulumi.getter(name="epRegistry")
    def ep_registry(self) -> Optional[str]:
        return pulumi.get(self, "ep_registry")

    @property
    @pulumi.getter(name="gbpPodSubnet")
    def gbp_pod_subnet(self) -> Optional[str]:
        return pulumi.get(self, "gbp_pod_subnet")

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[str]:
        return pulumi.get(self, "host_agent_log_level")

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_policy")

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_secret")

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[str]:
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[str]:
        return pulumi.get(self, "install_istio")

    @property
    @pulumi.getter(name="istioProfile")
    def istio_profile(self) -> Optional[str]:
        return pulumi.get(self, "istio_profile")

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "kafka_brokers")

    @property
    @pulumi.getter(name="kafkaClientCrt")
    def kafka_client_crt(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_crt")

    @property
    @pulumi.getter(name="kafkaClientKey")
    def kafka_client_key(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_key")

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[str]:
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[str]:
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[str]:
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[str]:
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[str]:
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[str]:
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[str]:
        return pulumi.get(self, "opflex_log_level")

    @property
    @pulumi.getter(name="opflexMode")
    def opflex_mode(self) -> Optional[str]:
        return pulumi.get(self, "opflex_mode")

    @property
    @pulumi.getter(name="opflexServerPort")
    def opflex_server_port(self) -> Optional[str]:
        return pulumi.get(self, "opflex_server_port")

    @property
    @pulumi.getter(name="overlayVrfName")
    def overlay_vrf_name(self) -> Optional[str]:
        return pulumi.get(self, "overlay_vrf_name")

    @property
    @pulumi.getter(name="ovsMemoryLimit")
    def ovs_memory_limit(self) -> Optional[str]:
        return pulumi.get(self, "ovs_memory_limit")

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[str]:
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[str]:
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[str]:
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[str]:
        return pulumi.get(self, "run_opflex_server_container")

    @property
    @pulumi.getter(name="serviceMonitorInterval")
    def service_monitor_interval(self) -> Optional[str]:
        return pulumi.get(self, "service_monitor_interval")

    @property
    @pulumi.getter(name="snatContractScope")
    def snat_contract_scope(self) -> Optional[str]:
        return pulumi.get(self, "snat_contract_scope")

    @property
    @pulumi.getter(name="snatNamespace")
    def snat_namespace(self) -> Optional[str]:
        return pulumi.get(self, "snat_namespace")

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[str]:
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[str]:
        return pulumi.get(self, "sriov_enable")

    @property
    @pulumi.getter(name="subnetDomainName")
    def subnet_domain_name(self) -> Optional[str]:
        return pulumi.get(self, "subnet_domain_name")

    @property
    @pulumi.getter
    def tenant(self) -> Optional[str]:
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[str]:
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[str]:
        return pulumi.get(self, "use_privileged_container")

    @property
    @pulumi.getter(name="vmmController")
    def vmm_controller(self) -> Optional[str]:
        return pulumi.get(self, "vmm_controller")

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[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[str] = None):
        if cloud_provider is not None:
            pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> Optional[str]:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[str]:
        return pulumi.get(self, "iface")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProvider(dict):
    def __init__(__self__, *,
                 iface: Optional[str] = None):
        if iface is not None:
            pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> Optional[str]:
        return pulumi.get(self, "iface")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProvider(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dockerSocket":
            suggest = "docker_socket"
        elif key == "hostnameOverride":
            suggest = "hostname_override"
        elif key == "internalAddress":
            suggest = "internal_address"
        elif key == "nodeId":
            suggest = "node_id"
        elif key == "sshAgentAuth":
            suggest = "ssh_agent_auth"
        elif key == "sshKey":
            suggest = "ssh_key"
        elif key == "sshKeyPath":
            suggest = "ssh_key_path"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigNode.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 address: str,
                 roles: Sequence[str],
                 user: str,
                 docker_socket: Optional[str] = None,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None,
                 ssh_key: Optional[str] = None,
                 ssh_key_path: Optional[str] = None):
        """
        :param Mapping[str, Any] labels: Labels for the cluster template (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "user", user)
        if docker_socket is not None:
            pulumi.set(__self__, "docker_socket", docker_socket)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)
        if ssh_key is not None:
            pulumi.set(__self__, "ssh_key", ssh_key)
        if ssh_key_path is not None:
            pulumi.set(__self__, "ssh_key_path", ssh_key_path)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> Optional[str]:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> Optional[str]:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[str]:
        return pulumi.get(self, "ssh_key_path")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ecrCredentialPlugin":
            suggest = "ecr_credential_plugin"
        elif key == "isDefault":
            suggest = "is_default"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :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) -> 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[bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "awsAccessKeyId":
            suggest = "aws_access_key_id"
        elif key == "awsSecretAccessKey":
            suggest = "aws_secret_access_key"
        elif key == "awsSessionToken":
            suggest = "aws_session_token"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPlugin.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

    @property
    @pulumi.getter(name="awsAccessKeyId")
    def aws_access_key_id(self) -> Optional[str]:
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> Optional[str]:
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[str]:
        return pulumi.get(self, "aws_session_token")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kubeApi":
            suggest = "kube_api"
        elif key == "kubeController":
            suggest = "kube_controller"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServices.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 etcd: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd'] = None,
                 kube_api: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi'] = None,
                 kube_controller: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController'] = None,
                 kubelet: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet'] = None,
                 kubeproxy: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy'] = None,
                 scheduler: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler'] = None):
        if etcd is not None:
            pulumi.set(__self__, "etcd", etcd)
        if kube_api is not None:
            pulumi.set(__self__, "kube_api", kube_api)
        if kube_controller is not None:
            pulumi.set(__self__, "kube_controller", kube_controller)
        if kubelet is not None:
            pulumi.set(__self__, "kubelet", kubelet)
        if kubeproxy is not None:
            pulumi.set(__self__, "kubeproxy", kubeproxy)
        if scheduler is not None:
            pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd']:
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi']:
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController']:
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet']:
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy']:
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler']:
        return pulumi.get(self, "scheduler")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backupConfig":
            suggest = "backup_config"
        elif key == "caCert":
            suggest = "ca_cert"
        elif key == "externalUrls":
            suggest = "external_urls"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcd.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 backup_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig'] = None,
                 ca_cert: Optional[str] = None,
                 cert: Optional[str] = None,
                 creation: Optional[str] = None,
                 external_urls: Optional[Sequence[str]] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 image: Optional[str] = None,
                 key: Optional[str] = None,
                 path: Optional[str] = None,
                 retention: Optional[str] = None,
                 snapshot: Optional[bool] = None,
                 uid: Optional[int] = None):
        if backup_config is not None:
            pulumi.set(__self__, "backup_config", backup_config)
        if ca_cert is not None:
            pulumi.set(__self__, "ca_cert", ca_cert)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if creation is not None:
            pulumi.set(__self__, "creation", creation)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if snapshot is not None:
            pulumi.set(__self__, "snapshot", snapshot)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig']:
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> Optional[str]:
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> Optional[str]:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> Optional[str]:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[int]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> Optional[str]:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> Optional[str]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> Optional[bool]:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter
    def uid(self) -> Optional[int]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalHours":
            suggest = "interval_hours"
        elif key == "s3BackupConfig":
            suggest = "s3_backup_config"
        elif key == "safeTimestamp":
            suggest = "safe_timestamp"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "customCa":
            suggest = "custom_ca"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "admissionConfiguration":
            suggest = "admission_configuration"
        elif key == "alwaysPullImages":
            suggest = "always_pull_images"
        elif key == "auditLog":
            suggest = "audit_log"
        elif key == "eventRateLimit":
            suggest = "event_rate_limit"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "podSecurityPolicy":
            suggest = "pod_security_policy"
        elif key == "secretsEncryptionConfig":
            suggest = "secrets_encryption_config"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"
        elif key == "serviceNodePortRange":
            suggest = "service_node_port_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApi.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 admission_configuration: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration'] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog'] = None,
                 event_rate_limit: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit'] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig'] = None,
                 service_cluster_ip_range: Optional[str] = None,
                 service_node_port_range: Optional[str] = None):
        """
        :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 pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if service_node_port_range is not None:
            pulumi.set(__self__, "service_node_port_range", service_node_port_range)

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfiguration']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig']:
        return pulumi.get(self, "secrets_encryption_config")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[str]:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> Optional[str]:
        return pulumi.get(self, "service_node_port_range")


@pulumi.output_type
class 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[str] = None,
                 kind: Optional[str] = None,
                 plugins: Optional[Sequence['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPlugin']] = None):
        """
        :param str api_version: Admission configuration ApiVersion
        :param 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[str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[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[str] = None,
                 name: Optional[str] = None,
                 path: Optional[str] = None):
        """
        :param str configuration: Plugin configuration
        :param str name: The cluster template name (string)
        :param 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[str]:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLog(dict):
    def __init__(__self__, *,
                 configuration: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration'] = None,
                 enabled: Optional[bool] = None):
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration']:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxAge":
            suggest = "max_age"
        elif key == "maxBackup":
            suggest = "max_backup"
        elif key == "maxSize":
            suggest = "max_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = None,
                 path: Optional[str] = None,
                 policy: Optional[str] = None):
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)
        if policy is not None:
            pulumi.set(__self__, "policy", policy)

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def policy(self) -> Optional[str]:
        return pulumi.get(self, "policy")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimit(dict):
    def __init__(__self__, *,
                 configuration: Optional[str] = None,
                 enabled: Optional[bool] = None):
        if configuration is not None:
            pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> Optional[str]:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customConfig":
            suggest = "custom_config"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 custom_config: Optional[str] = None,
                 enabled: Optional[bool] = None):
        if custom_config is not None:
            pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> Optional[str]:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterCidr":
            suggest = "cluster_cidr"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "serviceClusterIpRange":
            suggest = "service_cluster_ip_range"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeController.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_cidr: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None,
                 service_cluster_ip_range: Optional[str] = None):
        if cluster_cidr is not None:
            pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if service_cluster_ip_range is not None:
            pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> Optional[str]:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> Optional[str]:
        return pulumi.get(self, "service_cluster_ip_range")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterDnsServer":
            suggest = "cluster_dns_server"
        elif key == "clusterDomain":
            suggest = "cluster_domain"
        elif key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"
        elif key == "failSwapOn":
            suggest = "fail_swap_on"
        elif key == "generateServingCertificate":
            suggest = "generate_serving_certificate"
        elif key == "infraContainerImage":
            suggest = "infra_container_image"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubelet.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_dns_server: Optional[str] = None,
                 cluster_domain: Optional[str] = None,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 fail_swap_on: Optional[bool] = None,
                 generate_serving_certificate: Optional[bool] = None,
                 image: Optional[str] = None,
                 infra_container_image: Optional[str] = None):
        if cluster_dns_server is not None:
            pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        if cluster_domain is not None:
            pulumi.set(__self__, "cluster_domain", cluster_domain)
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if fail_swap_on is not None:
            pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)
        if image is not None:
            pulumi.set(__self__, "image", image)
        if infra_container_image is not None:
            pulumi.set(__self__, "infra_container_image", infra_container_image)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> Optional[str]:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> Optional[str]:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> Optional[bool]:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "generate_serving_certificate")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> Optional[str]:
        return pulumi.get(self, "infra_container_image")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "extraArgs":
            suggest = "extra_args"
        elif key == "extraBinds":
            suggest = "extra_binds"
        elif key == "extraEnvs":
            suggest = "extra_envs"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesScheduler.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 extra_args: Optional[Mapping[str, Any]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 image: Optional[str] = None):
        if extra_args is not None:
            pulumi.set(__self__, "extra_args", extra_args)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if image is not None:
            pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        return pulumi.get(self, "image")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "drainInput":
            suggest = "drain_input"
        elif key == "maxUnavailableControlplane":
            suggest = "max_unavailable_controlplane"
        elif key == "maxUnavailableWorker":
            suggest = "max_unavailable_worker"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 drain: Optional[bool] = None,
                 drain_input: Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput'] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if drain_input is not None:
            pulumi.set(__self__, "drain_input", drain_input)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> Optional['outputs.ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput']:
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deleteLocalData":
            suggest = "delete_local_data"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "ignoreDaemonSets":
            suggest = "ignore_daemon_sets"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInput.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class ClusterTemplateTemplateRevisionQuestion(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        """
        :param str default: Default variable value
        :param str variable: Variable name
        :param bool required: Required variable
        :param 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) -> str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class ClusterV2AgentEnvVar(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the cluster.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        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"

        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[str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterV2ClusterAgentDeploymentCustomizationOverrideResourceRequirement']] = None):
        """
        :param Sequence['ClusterV2ClusterAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param 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
        """
        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.ClusterV2ClusterAgentDeploymentCustomizationAppendToleration']]:
        """
        User defined tolerations to append to agent
        """
        return pulumi.get(self, "append_tolerations")

    @property
    @pulumi.getter(name="overrideAffinity")
    def override_affinity(self) -> Optional[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")


@pulumi.output_type
class ClusterV2ClusterAgentDeploymentCustomizationAppendToleration(dict):
    def __init__(__self__, *,
                 key: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class 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[str] = None,
                 cpu_request: Optional[str] = None,
                 memory_limit: Optional[str] = None,
                 memory_request: Optional[str] = None):
        """
        :param str cpu_limit: The maximum CPU limit for agent
        :param str cpu_request: The minimum CPU required for agent
        :param str memory_limit: The maximum memory limit for agent
        :param 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[str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[str]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[str]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[str]:
        """
        The minimum memory required for agent
        """
        return pulumi.get(self, "memory_request")


@pulumi.output_type
class ClusterV2ClusterRegistrationToken(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "insecureCommand":
            suggest = "insecure_command"
        elif key == "insecureNodeCommand":
            suggest = "insecure_node_command"
        elif key == "insecureWindowsNodeCommand":
            suggest = "insecure_windows_node_command"
        elif key == "manifestUrl":
            suggest = "manifest_url"
        elif key == "nodeCommand":
            suggest = "node_command"
        elif key == "windowsNodeCommand":
            suggest = "windows_node_command"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2ClusterRegistrationToken. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2ClusterRegistrationToken.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2ClusterRegistrationToken.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, Any]] = None,
                 cluster_id: Optional[str] = None,
                 command: Optional[str] = None,
                 id: Optional[str] = None,
                 insecure_command: Optional[str] = None,
                 insecure_node_command: Optional[str] = None,
                 insecure_windows_node_command: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 manifest_url: Optional[str] = None,
                 name: Optional[str] = None,
                 node_command: Optional[str] = None,
                 token: Optional[str] = None,
                 windows_node_command: Optional[str] = None):
        """
        :param Mapping[str, Any] annotations: Annotations for the Cluster.
        :param str id: (Computed, string) The ID of the resource.
        :param Mapping[str, Any] labels: Labels for the Cluster.
        :param str name: The name of the cluster.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if command is not None:
            pulumi.set(__self__, "command", command)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if insecure_command is not None:
            pulumi.set(__self__, "insecure_command", insecure_command)
        if insecure_node_command is not None:
            pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        if insecure_windows_node_command is not None:
            pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if manifest_url is not None:
            pulumi.set(__self__, "manifest_url", manifest_url)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if node_command is not None:
            pulumi.set(__self__, "node_command", node_command)
        if token is not None:
            pulumi.set(__self__, "token", token)
        if windows_node_command is not None:
            pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, Any]]:
        """
        Annotations for the Cluster.
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[str]:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> Optional[str]:
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        (Computed, string) The ID of the resource.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> Optional[str]:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> Optional[str]:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> Optional[str]:
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels for the Cluster.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> Optional[str]:
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> Optional[str]:
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> Optional[str]:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> Optional[str]:
        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[str] = None,
                 override_resource_requirements: Optional[Sequence['outputs.ClusterV2FleetAgentDeploymentCustomizationOverrideResourceRequirement']] = None):
        """
        :param Sequence['ClusterV2FleetAgentDeploymentCustomizationAppendTolerationArgs'] append_tolerations: User defined tolerations to append to agent
        :param 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[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: str,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 seconds: Optional[int] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if seconds is not None:
            pulumi.set(__self__, "seconds", seconds)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def seconds(self) -> Optional[int]:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class 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[str] = None,
                 cpu_request: Optional[str] = None,
                 memory_limit: Optional[str] = None,
                 memory_request: Optional[str] = None):
        """
        :param str cpu_limit: The maximum CPU limit for agent
        :param str cpu_request: The minimum CPU required for agent
        :param str memory_limit: The maximum memory limit for agent
        :param 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[str]:
        """
        The maximum CPU limit for agent
        """
        return pulumi.get(self, "cpu_limit")

    @property
    @pulumi.getter(name="cpuRequest")
    def cpu_request(self) -> Optional[str]:
        """
        The minimum CPU required for agent
        """
        return pulumi.get(self, "cpu_request")

    @property
    @pulumi.getter(name="memoryLimit")
    def memory_limit(self) -> Optional[str]:
        """
        The maximum memory limit for agent
        """
        return pulumi.get(self, "memory_limit")

    @property
    @pulumi.getter(name="memoryRequest")
    def memory_request(self) -> Optional[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[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class 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[str] = None,
                 chart_values: Optional[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[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 str additional_manifest: Cluster V2 additional manifest
        :param 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 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[str]:
        """
        Cluster V2 additional manifest
        """
        return pulumi.get(self, "additional_manifest")

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[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")
    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).
        """
        warnings.warn("""Use rancher2_cluster_v2.local_auth_endpoint instead""", DeprecationWarning)
        pulumi.log.warn("""local_auth_endpoint is deprecated: Use rancher2_cluster_v2.local_auth_endpoint instead""")

        return pulumi.get(self, "local_auth_endpoint")

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[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[bool] = None,
                 s3_config: Optional['outputs.ClusterV2RkeConfigEtcdS3Config'] = None,
                 snapshot_retention: Optional[int] = None,
                 snapshot_schedule_cron: Optional[str] = None):
        """
        :param bool disable_snapshots: Disable ETCD snapshots
        :param 'ClusterV2RkeConfigEtcdS3ConfigArgs' s3_config: ETCD snapshot S3 config
        :param int snapshot_retention: ETCD snapshot retention
        :param 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[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[int]:
        """
        ETCD snapshot retention
        """
        return pulumi.get(self, "snapshot_retention")

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[str]:
        """
        ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        return pulumi.get(self, "snapshot_schedule_cron")


@pulumi.output_type
class ClusterV2RkeConfigEtcdS3Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudCredentialName":
            suggest = "cloud_credential_name"
        elif key == "endpointCa":
            suggest = "endpoint_ca"
        elif key == "skipSslVerify":
            suggest = "skip_ssl_verify"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ClusterV2RkeConfigEtcdS3Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ClusterV2RkeConfigEtcdS3Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ClusterV2RkeConfigEtcdS3Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: str,
                 endpoint: str,
                 cloud_credential_name: Optional[str] = None,
                 endpoint_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 skip_ssl_verify: Optional[bool] = None):
        """
        :param str bucket: ETCD snapshot S3 bucket
        :param str endpoint: ETCD snapshot S3 endpoint
        :param str cloud_credential_name: ETCD snapshot S3 cloud credential name
        :param str endpoint_ca: ETCD snapshot S3 endpoint CA
        :param str folder: ETCD snapshot S3 folder
        :param str region: ETCD snapshot S3 region
        :param 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) -> str:
        """
        ETCD snapshot S3 bucket
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        ETCD snapshot S3 endpoint
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[str]:
        """
        ETCD snapshot S3 cloud credential name
        """
        return pulumi.get(self, "cloud_credential_name")

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[str]:
        """
        ETCD snapshot S3 endpoint CA
        """
        return pulumi.get(self, "endpoint_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        """
        ETCD snapshot S3 folder
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        ETCD snapshot S3 region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[bool]:
        """
        Disable ETCD skip ssl verify
        """
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class ClusterV2RkeConfigEtcdSnapshotCreate(dict):
    def __init__(__self__, *,
                 generation: int):
        """
        :param int generation: ETCD generation to initiate a snapshot
        """
        pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def generation(self) -> 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: int,
                 name: str,
                 restore_rke_config: Optional[str] = None):
        """
        :param int generation: ETCD snapshot desired generation
        :param str name: The name of the cluster.
        :param 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) -> int:
        """
        ETCD snapshot desired generation
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="restoreRkeConfig")
    def restore_rke_config(self) -> Optional[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[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class 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: str,
                 annotations: Optional[Mapping[str, Any]] = None,
                 cloud_credential_secret_name: Optional[str] = None,
                 control_plane_role: Optional[bool] = None,
                 drain_before_delete: Optional[bool] = None,
                 etcd_role: Optional[bool] = None,
                 hostname_length_limit: Optional[int] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 machine_labels: Optional[Mapping[str, Any]] = None,
                 max_unhealthy: Optional[str] = None,
                 node_drain_timeout: Optional[int] = None,
                 node_startup_timeout_seconds: Optional[int] = None,
                 paused: Optional[bool] = None,
                 quantity: Optional[int] = None,
                 rolling_update: Optional['outputs.ClusterV2RkeConfigMachinePoolRollingUpdate'] = None,
                 taints: Optional[Sequence['outputs.ClusterV2RkeConfigMachinePoolTaint']] = None,
                 unhealthy_node_timeout_seconds: Optional[int] = None,
                 unhealthy_range: Optional[str] = None,
                 worker_role: Optional[bool] = None):
        """
        :param 'ClusterV2RkeConfigMachinePoolMachineConfigArgs' machine_config: Machine config data
        :param str name: The name of the cluster.
        :param Mapping[str, Any] annotations: Annotations for the Cluster.
        :param 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 bool control_plane_role: Machine pool control plane role
        :param bool drain_before_delete: Machine pool drain before delete
        :param bool etcd_role: Machine pool etcd role
        :param int hostname_length_limit: maximum length for autogenerated hostname
        :param Mapping[str, Any] labels: Labels for the Cluster.
        :param Mapping[str, Any] machine_labels: Labels of the machine
        :param str max_unhealthy: max unhealthy nodes for automated replacement to be allowed
        :param int node_drain_timeout: seconds to wait for machine pool drain to complete before machine deletion
        :param int node_startup_timeout_seconds: seconds a new node has to become active before it is replaced
        :param bool paused: Machine pool paused
        :param int quantity: Machine pool quantity
        :param 'ClusterV2RkeConfigMachinePoolRollingUpdateArgs' rolling_update: Machine pool rolling update
        :param Sequence['ClusterV2RkeConfigMachinePoolTaintArgs'] taints: Machine pool taints
        :param int unhealthy_node_timeout_seconds: seconds an unhealthy node has to become active before it is replaced
        :param str unhealthy_range: range of unhealthy nodes for automated replacement to be allowed
        :param 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) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, Any]]:
        """
        Annotations for the Cluster.
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="cloudCredentialSecretName")
    def cloud_credential_secret_name(self) -> Optional[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[bool]:
        """
        Machine pool control plane role
        """
        return pulumi.get(self, "control_plane_role")

    @property
    @pulumi.getter(name="drainBeforeDelete")
    def drain_before_delete(self) -> Optional[bool]:
        """
        Machine pool drain before delete
        """
        return pulumi.get(self, "drain_before_delete")

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[bool]:
        """
        Machine pool etcd role
        """
        return pulumi.get(self, "etcd_role")

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels for the Cluster.
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="machineLabels")
    def machine_labels(self) -> Optional[Mapping[str, Any]]:
        """
        Labels of the machine
        """
        return pulumi.get(self, "machine_labels")

    @property
    @pulumi.getter(name="maxUnhealthy")
    def max_unhealthy(self) -> Optional[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[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[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[bool]:
        """
        Machine pool paused
        """
        return pulumi.get(self, "paused")

    @property
    @pulumi.getter
    def quantity(self) -> Optional[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[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[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[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[int] = None):
        """
        :param 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[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: str,
                 name: str,
                 api_version: Optional[str] = None):
        """
        :param str kind: Machine config kind
        :param str name: The name of the cluster.
        :param 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) -> str:
        """
        Machine config kind
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[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[str] = None,
                 max_unavailable: Optional[str] = None):
        """
        :param str max_surge: Rolling update max surge
        :param 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[str]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[str]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class ClusterV2RkeConfigMachinePoolTaint(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class 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[str] = None,
                 machine_label_selector: Optional['outputs.ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelector'] = None):
        """
        :param 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[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, Any]] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, Any] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[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, Any]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpression(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: Label selector requirement key
        :param str operator: Label selector operator
        :param Sequence[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[str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[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: str,
                 default_permissions: Optional[str] = None,
                 items: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItem']] = None):
        """
        :param str name: The name of the cluster.
        :param 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) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[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: str,
                 path: str,
                 dynamic: Optional[bool] = None,
                 hash: Optional[str] = None,
                 permissions: Optional[str] = None):
        """
        :param str key: The key of the item(file) to retrieve
        :param str path: The path to put the file in the target node
        :param bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param 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) -> str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[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[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[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: str,
                 default_permissions: Optional[str] = None,
                 items: Optional[Sequence['outputs.ClusterV2RkeConfigMachineSelectorFileFileSourceSecretItem']] = None):
        """
        :param str name: The name of the cluster.
        :param 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) -> str:
        """
        The name of the cluster.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[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: str,
                 path: str,
                 dynamic: Optional[bool] = None,
                 hash: Optional[str] = None,
                 permissions: Optional[str] = None):
        """
        :param str key: The key of the item(file) to retrieve
        :param str path: The path to put the file in the target node
        :param bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param 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) -> str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[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[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[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, Any]] = None):
        """
        :param Sequence['ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, Any] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[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, Any]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class ClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpression(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: Label selector requirement key
        :param str operator: Label selector operator
        :param Sequence[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[str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[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: str,
                 auth_config_secret_name: Optional[str] = None,
                 ca_bundle: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 tls_secret_name: Optional[str] = None):
        """
        :param str hostname: Registry hostname
        :param str auth_config_secret_name: Registry auth config secret name
        :param str ca_bundle: Registry CA bundle
        :param bool insecure: Registry insecure connectivity
        :param 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) -> str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[str]:
        """
        Registry auth config secret name
        """
        return pulumi.get(self, "auth_config_secret_name")

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[str]:
        """
        Registry CA bundle
        """
        return pulumi.get(self, "ca_bundle")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        """
        Registry insecure connectivity
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[str]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key
        """
        return pulumi.get(self, "tls_secret_name")


@pulumi.output_type
class ClusterV2RkeConfigRegistriesMirror(dict):
    def __init__(__self__, *,
                 hostname: str,
                 endpoints: Optional[Sequence[str]] = None,
                 rewrites: Optional[Mapping[str, Any]] = None):
        """
        :param str hostname: Registry hostname
        :param Sequence[str] endpoints: Registry mirror endpoints
        :param Mapping[str, Any] rewrites: Registry mirror rewrites
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

    @property
    @pulumi.getter
    def hostname(self) -> str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[Sequence[str]]:
        """
        Registry mirror endpoints
        """
        return pulumi.get(self, "endpoints")

    @property
    @pulumi.getter
    def rewrites(self) -> Optional[Mapping[str, Any]]:
        """
        Registry mirror rewrites
        """
        return pulumi.get(self, "rewrites")


@pulumi.output_type
class ClusterV2RkeConfigRotateCertificates(dict):
    def __init__(__self__, *,
                 generation: int,
                 services: Optional[Sequence[str]] = None):
        """
        :param int generation: Desired certificate rotation generation.
        :param Sequence[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) -> int:
        """
        Desired certificate rotation generation.
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[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[str] = None,
                 control_plane_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptions'] = None,
                 worker_concurrency: Optional[str] = None,
                 worker_drain_options: Optional['outputs.ClusterV2RkeConfigUpgradeStrategyWorkerDrainOptions'] = None):
        """
        :param str control_plane_concurrency: How many controlplane nodes should be upgrade at time, 0 is infinite. Percentages are also accepted
        :param 'ClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsArgs' control_plane_drain_options: Controlplane nodes drain options
        :param 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[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[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[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param bool delete_empty_dir_data: Drain options delete empty dir data
        :param bool disable_eviction: Drain options disable eviction
        :param bool enabled: Drain options enabled?
        :param bool force: Drain options force
        :param int grace_period: Drain options grace period
        :param bool ignore_daemon_sets: Drain options ignore daemon sets
        :param bool ignore_errors: Drain options ignore errors
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param 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[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[bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[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[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[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[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None,
                 skip_wait_for_delete_timeout_seconds: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param bool delete_empty_dir_data: Drain options delete empty dir data
        :param bool disable_eviction: Drain options disable eviction
        :param bool enabled: Drain options enabled?
        :param bool force: Drain options force
        :param int grace_period: Drain options grace period
        :param bool ignore_daemon_sets: Drain options ignore daemon sets
        :param bool ignore_errors: Drain options ignore errors
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param 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[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[bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[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[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[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[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.EtcdBackupBackupConfigS3BackupConfig'] = None,
                 safe_timestamp: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.EtcdBackupBackupConfigS3BackupConfig']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class EtcdBackupBackupConfigS3BackupConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"
        elif key == "accessKey":
            suggest = "access_key"
        elif key == "customCa":
            suggest = "custom_ca"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in EtcdBackupBackupConfigS3BackupConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        EtcdBackupBackupConfigS3BackupConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        EtcdBackupBackupConfigS3BackupConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GlobalDnsProviderAlidnsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderAlidnsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderAlidnsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderAlidnsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> str:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GlobalDnsProviderCloudflareConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiEmail":
            suggest = "api_email"
        elif key == "apiKey":
            suggest = "api_key"
        elif key == "proxySetting":
            suggest = "proxy_setting"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderCloudflareConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderCloudflareConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderCloudflareConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_email: str,
                 api_key: str,
                 proxy_setting: Optional[bool] = None):
        pulumi.set(__self__, "api_email", api_email)
        pulumi.set(__self__, "api_key", api_key)
        if proxy_setting is not None:
            pulumi.set(__self__, "proxy_setting", proxy_setting)

    @property
    @pulumi.getter(name="apiEmail")
    def api_email(self) -> str:
        return pulumi.get(self, "api_email")

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="proxySetting")
    def proxy_setting(self) -> Optional[bool]:
        return pulumi.get(self, "proxy_setting")


@pulumi.output_type
class GlobalDnsProviderRoute53Config(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKey":
            suggest = "access_key"
        elif key == "secretKey":
            suggest = "secret_key"
        elif key == "credentialsPath":
            suggest = "credentials_path"
        elif key == "roleArn":
            suggest = "role_arn"
        elif key == "zoneType":
            suggest = "zone_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalDnsProviderRoute53Config. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalDnsProviderRoute53Config.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalDnsProviderRoute53Config.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 credentials_path: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 zone_type: Optional[str] = None):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if credentials_path is not None:
            pulumi.set(__self__, "credentials_path", credentials_path)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if zone_type is not None:
            pulumi.set(__self__, "zone_type", zone_type)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> str:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="credentialsPath")
    def credentials_path(self) -> Optional[str]:
        return pulumi.get(self, "credentials_path")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[str]:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="zoneType")
    def zone_type(self) -> Optional[str]:
        return pulumi.get(self, "zone_type")


@pulumi.output_type
class GlobalRoleRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroups":
            suggest = "api_groups"
        elif key == "nonResourceUrls":
            suggest = "non_resource_urls"
        elif key == "resourceNames":
            suggest = "resource_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in GlobalRoleRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        GlobalRoleRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        GlobalRoleRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups
        :param Sequence[str] non_resource_urls: Policy rule non resource urls
        :param Sequence[str] resource_names: Policy rule resource names
        :param Sequence[str] resources: Policy rule resources
        :param Sequence[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[str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[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: str,
                 region: str,
                 security_groups: Sequence[str],
                 subnet_id: str,
                 vpc_id: str,
                 zone: str,
                 access_key: Optional[str] = None,
                 block_duration_minutes: Optional[str] = None,
                 device_name: Optional[str] = None,
                 encrypt_ebs_volume: Optional[bool] = None,
                 endpoint: Optional[str] = None,
                 http_endpoint: Optional[str] = None,
                 http_tokens: Optional[str] = None,
                 iam_instance_profile: Optional[str] = None,
                 insecure_transport: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 kms_key: Optional[str] = None,
                 monitoring: Optional[bool] = None,
                 open_ports: Optional[Sequence[str]] = None,
                 private_address_only: Optional[bool] = None,
                 request_spot_instance: Optional[bool] = None,
                 retries: Optional[str] = None,
                 root_size: Optional[str] = None,
                 secret_key: Optional[str] = None,
                 security_group_readonly: Optional[bool] = None,
                 session_token: Optional[str] = None,
                 spot_price: Optional[str] = None,
                 ssh_key_contents: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 use_ebs_optimized_instance: Optional[bool] = None,
                 use_private_address: Optional[bool] = None,
                 userdata: Optional[str] = None,
                 volume_type: Optional[str] = None):
        """
        :param str ami: AWS machine image
        :param str region: AWS Region
        :param Sequence[str] security_groups: AWS VPC security group
        :param str subnet_id: AWS VPC subnet id
        :param str vpc_id: AWS VPC id
        :param str zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param str access_key: AWS Access Key
        :param str block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param str device_name: AWS root device name
        :param bool encrypt_ebs_volume: Encrypt EBS volume
        :param str endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param str http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param str http_tokens: The state of token usage for your instance metadata requests
        :param str iam_instance_profile: AWS IAM Instance Profile
        :param bool insecure_transport: Disable SSL when sending requests
        :param str instance_type: AWS instance type
        :param str kms_key: Custom KMS key ID using the AWS Managed CMK
        :param bool monitoring: Set this flag to enable CloudWatch monitoring
        :param Sequence[str] open_ports: Make the specified port number accessible from the Internet
        :param bool private_address_only: Only use a private IP address
        :param bool request_spot_instance: Set this flag to request spot instance
        :param str retries: Set retry count for recoverable failures (use -1 to disable)
        :param str root_size: AWS root disk size (in GB)
        :param str secret_key: AWS Secret Key
        :param bool security_group_readonly: Skip adding default rules to security groups
        :param str session_token: AWS Session Token
        :param str spot_price: AWS spot instance bid price (in dollar)
        :param str ssh_key_contents: SSH Key file contents for sshKeyContents
        :param str ssh_user: Set the name of the ssh user
        :param str tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param bool use_ebs_optimized_instance: Create an EBS optimized instance
        :param bool use_private_address: Force the usage of private IP address
        :param str userdata: Path to file with cloud-init user data
        :param 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) -> str:
        """
        AWS machine image
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        AWS Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Sequence[str]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        AWS VPC subnet id
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        AWS VPC id
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def zone(self) -> 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[str]:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[str]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        """
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[str]:
        """
        AWS root device name
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[bool]:
        """
        Encrypt EBS volume
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[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[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[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[str]:
        """
        AWS IAM Instance Profile
        """
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[bool]:
        """
        Disable SSL when sending requests
        """
        return pulumi.get(self, "insecure_transport")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        AWS instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[str]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[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[bool]:
        """
        Set this flag to request spot instance
        """
        return pulumi.get(self, "request_spot_instance")

    @property
    @pulumi.getter
    def retries(self) -> Optional[str]:
        """
        Set retry count for recoverable failures (use -1 to disable)
        """
        return pulumi.get(self, "retries")

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[str]:
        """
        AWS root disk size (in GB)
        """
        return pulumi.get(self, "root_size")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[bool]:
        """
        Skip adding default rules to security groups
        """
        return pulumi.get(self, "security_group_readonly")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[str]:
        """
        AWS Session Token
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[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[str]:
        """
        SSH Key file contents for sshKeyContents
        """
        return pulumi.get(self, "ssh_key_contents")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        Set the name of the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[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[bool]:
        """
        Force the usage of private IP address
        """
        return pulumi.get(self, "use_private_address")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[str]:
        """
        Path to file with cloud-init user data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[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[bool] = None,
                 availability_set: Optional[str] = None,
                 availability_zone: Optional[str] = None,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 custom_data: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 dns: Optional[str] = None,
                 docker_port: Optional[str] = None,
                 environment: Optional[str] = None,
                 fault_domain_count: Optional[str] = None,
                 image: Optional[str] = None,
                 location: Optional[str] = None,
                 managed_disks: Optional[bool] = None,
                 no_public_ip: Optional[bool] = None,
                 nsg: Optional[str] = None,
                 open_ports: Optional[Sequence[str]] = None,
                 private_address_only: Optional[bool] = None,
                 private_ip_address: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 static_public_ip: Optional[bool] = None,
                 storage_type: Optional[str] = None,
                 subnet: Optional[str] = None,
                 subnet_prefix: Optional[str] = None,
                 subscription_id: Optional[str] = None,
                 tags: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 update_domain_count: Optional[str] = None,
                 use_private_ip: Optional[bool] = None,
                 use_public_ip_standard_sku: Optional[bool] = None,
                 vnet: Optional[str] = None):
        """
        :param bool accelerated_networking: Use Accelerated Networking when creating a network interface for the Azure VM
        :param str availability_set: Azure Availability Set to place the virtual machine into
        :param str availability_zone: The Availability Zone that the Azure VM should be created in
        :param str client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param str client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param str custom_data: Path to file with custom-data
        :param str disk_size: Disk size if using managed disk
        :param str dns: A unique DNS label for the public IP adddress
        :param str docker_port: Port number for Docker engine
        :param str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param str fault_domain_count: Fault domain count to use for availability set
        :param str image: Azure virtual machine OS image
        :param str location: Azure region to create the virtual machine
        :param bool managed_disks: Configures VM and availability set for managed disks
        :param bool no_public_ip: Do not create a public IP address for the machine
        :param str nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        :param Sequence[str] open_ports: Make the specified port number accessible from the Internet
        :param bool private_address_only: Only use a private IP address
        :param str private_ip_address: Specify a static private IP address for the machine
        :param str resource_group: Azure Resource Group name (will be created if missing)
        :param str size: Size for Azure Virtual Machine
        :param str ssh_user: Username for SSH login
        :param bool static_public_ip: Assign a static public IP address to the machine
        :param str storage_type: Type of Storage Account to host the OS Disk for the machine
        :param str subnet: Azure Subnet Name to be used within the Virtual Network
        :param str subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param str subscription_id: Azure Subscription ID
        :param str tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param str tenant_id: Azure Tenant ID
        :param str update_domain_count: Update domain count to use for availability set
        :param bool use_private_ip: Use private IP address of the machine to connect
        :param bool use_public_ip_standard_sku: Use the standard SKU when creating a Public IP for the Azure VM instance
        :param 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[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[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[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[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[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[str]:
        """
        Path to file with custom-data
        """
        return pulumi.get(self, "custom_data")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        Disk size if using managed disk
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def dns(self) -> Optional[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[str]:
        """
        Port number for Docker engine
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def environment(self) -> Optional[str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[str]:
        """
        Fault domain count to use for availability set
        """
        return pulumi.get(self, "fault_domain_count")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Azure virtual machine OS image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def location(self) -> Optional[str]:
        """
        Azure region to create the virtual machine
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[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[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[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[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[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[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[str]:
        """
        Azure Resource Group name (will be created if missing)
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Size for Azure Virtual Machine
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        Username for SSH login
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[bool]:
        """
        Assign a static public IP address to the machine
        """
        return pulumi.get(self, "static_public_ip")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[str]:
        """
        Type of Storage Account to host the OS Disk for the machine
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter
    def subnet(self) -> Optional[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[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[str]:
        """
        Azure Subscription ID
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[str]:
        """
        Azure Tenant ID
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="updateDomainCount")
    def update_domain_count(self) -> Optional[str]:
        """
        Update domain count to use for availability set
        """
        return pulumi.get(self, "update_domain_count")

    @property
    @pulumi.getter(name="usePrivateIp")
    def use_private_ip(self) -> Optional[bool]:
        """
        Use private IP address of the machine to connect
        """
        return pulumi.get(self, "use_private_ip")

    @property
    @pulumi.getter(name="usePublicIpStandardSku")
    def use_public_ip_standard_sku(self) -> Optional[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[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[str] = None,
                 backups: Optional[bool] = None,
                 image: Optional[str] = None,
                 ipv6: Optional[bool] = None,
                 monitoring: Optional[bool] = None,
                 private_networking: Optional[bool] = None,
                 region: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_key_contents: Optional[str] = None,
                 ssh_key_fingerprint: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 userdata: Optional[str] = None):
        """
        :param str access_token: Digital Ocean access token
        :param bool backups: Enable backups for droplet
        :param str image: Digital Ocean Image
        :param bool ipv6: Enable ipv6 for droplet
        :param bool monitoring: Enable monitoring for droplet
        :param bool private_networking: Enable private networking for droplet
        :param str region: Digital Ocean region
        :param str size: Digital Ocean size
        :param str ssh_key_contents: SSH private key contents
        :param str ssh_key_fingerprint: SSH key fingerprint
        :param str ssh_port: SSH port
        :param str ssh_user: SSH username
        :param str tags: Comma-separated list of tags to apply to the Droplet
        :param 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[str]:
        """
        Digital Ocean access token
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter
    def backups(self) -> Optional[bool]:
        """
        Enable backups for droplet
        """
        return pulumi.get(self, "backups")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Digital Ocean Image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[bool]:
        """
        Enable ipv6 for droplet
        """
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Enable monitoring for droplet
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[bool]:
        """
        Enable private networking for droplet
        """
        return pulumi.get(self, "private_networking")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Digital Ocean region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Digital Ocean size
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshKeyContents")
    def ssh_key_contents(self) -> Optional[str]:
        """
        SSH private key contents
        """
        return pulumi.get(self, "ssh_key_contents")

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[str]:
        """
        SSH key fingerprint
        """
        return pulumi.get(self, "ssh_key_fingerprint")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        SSH port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[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: str,
                 vm_namespace: str,
                 cpu_count: Optional[str] = None,
                 disk_bus: Optional[str] = None,
                 disk_info: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 image_name: Optional[str] = None,
                 memory_size: Optional[str] = None,
                 network_data: Optional[str] = None,
                 network_info: Optional[str] = None,
                 network_model: Optional[str] = None,
                 network_name: Optional[str] = None,
                 ssh_password: Optional[str] = None,
                 user_data: Optional[str] = None,
                 vm_affinity: Optional[str] = None):
        """
        :param str ssh_user: SSH username
        :param str vm_namespace: Virtual machine namespace
        :param str cpu_count: CPU count
        :param str disk_bus: Disk bus
        :param 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 str disk_size: Disk size (in GiB)
        :param str image_name: Image name
        :param str memory_size: Memory size (in GiB)
        :param str network_data: NetworkData content of cloud-init, base64 is supported
        :param str network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param str network_model: Network model
        :param str network_name: Network name
        :param str ssh_password: SSH password
        :param 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 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) -> str:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> str:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[str]:
        """
        CPU count
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="diskBus")
    def disk_bus(self) -> Optional[str]:
        """
        Disk bus
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_bus")

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[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")
    def disk_size(self) -> Optional[str]:
        """
        Disk size (in GiB)
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        """
        Image name
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")

        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[str]:
        """
        Memory size (in GiB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="networkData")
    def network_data(self) -> Optional[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[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")
    def network_model(self) -> Optional[str]:
        """
        Network model
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_model is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_model")

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[str]:
        """
        Network name
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_name is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[str]:
        """
        SSH password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[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[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[str] = None,
                 create_private_ip: Optional[bool] = None,
                 docker_port: Optional[str] = None,
                 image: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 label: Optional[str] = None,
                 region: Optional[str] = None,
                 root_pass: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 stackscript: Optional[str] = None,
                 stackscript_data: Optional[str] = None,
                 swap_size: Optional[str] = None,
                 tags: Optional[str] = None,
                 token: Optional[str] = None,
                 ua_prefix: Optional[str] = None):
        """
        :param str authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        :param bool create_private_ip: Create private IP for the instance
        :param str docker_port: Docker Port
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param str label: Linode Instance Label
        :param str region: Specifies the region (location) of the Linode instance
        :param str root_pass: Root Password
        :param str ssh_port: Linode Instance SSH Port
        :param str ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param str stackscript: Specifies the Linode StackScript to use to create the instance
        :param str stackscript_data: A JSON string specifying data for the selected StackScript
        :param str swap_size: Linode Instance Swap Size (MB)
        :param str tags: A comma separated list of tags to apply to the the Linode resource
        :param str token: Linode API Token
        :param 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[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[bool]:
        """
        Create private IP for the instance
        """
        return pulumi.get(self, "create_private_ip")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[str]:
        """
        Docker Port
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Linode Instance Label
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Specifies the region (location) of the Linode instance
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[str]:
        """
        Root Password
        """
        return pulumi.get(self, "root_pass")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        Linode Instance SSH Port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[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[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[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[str]:
        """
        Linode Instance Swap Size (MB)
        """
        return pulumi.get(self, "swap_size")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[str]:
        """
        Linode API Token
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[str]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        return pulumi.get(self, "ua_prefix")


@pulumi.output_type
class MachineConfigV2OpenstackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "activeTimeout":
            suggest = "active_timeout"
        elif key == "applicationCredentialId":
            suggest = "application_credential_id"
        elif key == "applicationCredentialName":
            suggest = "application_credential_name"
        elif key == "applicationCredentialSecret":
            suggest = "application_credential_secret"
        elif key == "bootFromVolume":
            suggest = "boot_from_volume"
        elif key == "configDrive":
            suggest = "config_drive"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "flavorId":
            suggest = "flavor_id"
        elif key == "flavorName":
            suggest = "flavor_name"
        elif key == "floatingIpPool":
            suggest = "floating_ip_pool"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "ipVersion":
            suggest = "ip_version"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "netId":
            suggest = "net_id"
        elif key == "netName":
            suggest = "net_name"
        elif key == "novaNetwork":
            suggest = "nova_network"
        elif key == "privateKeyFile":
            suggest = "private_key_file"
        elif key == "secGroups":
            suggest = "sec_groups"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "tenantDomainId":
            suggest = "tenant_domain_id"
        elif key == "tenantDomainName":
            suggest = "tenant_domain_name"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "userDataFile":
            suggest = "user_data_file"
        elif key == "userDomainId":
            suggest = "user_domain_id"
        elif key == "userDomainName":
            suggest = "user_domain_name"
        elif key == "volumeDevicePath":
            suggest = "volume_device_path"
        elif key == "volumeId":
            suggest = "volume_id"
        elif key == "volumeName":
            suggest = "volume_name"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MachineConfigV2OpenstackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MachineConfigV2OpenstackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MachineConfigV2OpenstackConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_url: str,
                 availability_zone: str,
                 region: str,
                 active_timeout: Optional[str] = None,
                 application_credential_id: Optional[str] = None,
                 application_credential_name: Optional[str] = None,
                 application_credential_secret: Optional[str] = None,
                 boot_from_volume: Optional[bool] = None,
                 cacert: Optional[str] = None,
                 config_drive: Optional[bool] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 endpoint_type: Optional[str] = None,
                 flavor_id: Optional[str] = None,
                 flavor_name: Optional[str] = None,
                 floating_ip_pool: Optional[str] = None,
                 image_id: Optional[str] = None,
                 image_name: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 ip_version: Optional[str] = None,
                 keypair_name: Optional[str] = None,
                 net_id: Optional[str] = None,
                 net_name: Optional[str] = None,
                 nova_network: Optional[bool] = None,
                 password: Optional[str] = None,
                 private_key_file: Optional[str] = None,
                 sec_groups: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tenant_domain_id: Optional[str] = None,
                 tenant_domain_name: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 user_data_file: Optional[str] = None,
                 user_domain_id: Optional[str] = None,
                 user_domain_name: Optional[str] = None,
                 username: Optional[str] = None,
                 volume_device_path: Optional[str] = None,
                 volume_id: Optional[str] = None,
                 volume_name: Optional[str] = None,
                 volume_size: Optional[str] = None,
                 volume_type: Optional[str] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_domain_id is not None:
            pulumi.set(__self__, "tenant_domain_id", tenant_domain_id)
        if tenant_domain_name is not None:
            pulumi.set(__self__, "tenant_domain_name", tenant_domain_name)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)
        if user_domain_id is not None:
            pulumi.set(__self__, "user_domain_id", user_domain_id)
        if user_domain_name is not None:
            pulumi.set(__self__, "user_domain_name", user_domain_name)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[str]:
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_id")

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_name")

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[bool]:
        return pulumi.get(self, "boot_from_volume")

    @property
    @pulumi.getter
    def cacert(self) -> Optional[str]:
        return pulumi.get(self, "cacert")

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[bool]:
        return pulumi.get(self, "config_drive")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[str]:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[str]:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[str]:
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="flavorId")
    def flavor_id(self) -> Optional[str]:
        return pulumi.get(self, "flavor_id")

    @property
    @pulumi.getter(name="flavorName")
    def flavor_name(self) -> Optional[str]:
        return pulumi.get(self, "flavor_name")

    @property
    @pulumi.getter(name="floatingIpPool")
    def floating_ip_pool(self) -> Optional[str]:
        return pulumi.get(self, "floating_ip_pool")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[str]:
        return pulumi.get(self, "ip_version")

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[str]:
        return pulumi.get(self, "keypair_name")

    @property
    @pulumi.getter(name="netId")
    def net_id(self) -> Optional[str]:
        return pulumi.get(self, "net_id")

    @property
    @pulumi.getter(name="netName")
    def net_name(self) -> Optional[str]:
        return pulumi.get(self, "net_name")

    @property
    @pulumi.getter(name="novaNetwork")
    def nova_network(self) -> Optional[bool]:
        return pulumi.get(self, "nova_network")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="privateKeyFile")
    def private_key_file(self) -> Optional[str]:
        return pulumi.get(self, "private_key_file")

    @property
    @pulumi.getter(name="secGroups")
    def sec_groups(self) -> Optional[str]:
        return pulumi.get(self, "sec_groups")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="tenantDomainId")
    def tenant_domain_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_domain_id")

    @property
    @pulumi.getter(name="tenantDomainName")
    def tenant_domain_name(self) -> Optional[str]:
        return pulumi.get(self, "tenant_domain_name")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[str]:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="userDataFile")
    def user_data_file(self) -> Optional[str]:
        return pulumi.get(self, "user_data_file")

    @property
    @pulumi.getter(name="userDomainId")
    def user_domain_id(self) -> Optional[str]:
        return pulumi.get(self, "user_domain_id")

    @property
    @pulumi.getter(name="userDomainName")
    def user_domain_name(self) -> Optional[str]:
        return pulumi.get(self, "user_domain_name")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[str]:
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[str]:
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[str]:
        return pulumi.get(self, "volume_name")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[str]:
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        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[str] = None,
                 cfgparams: Optional[Sequence[str]] = None,
                 clone_from: Optional[str] = None,
                 cloud_config: Optional[str] = None,
                 cloudinit: Optional[str] = None,
                 content_library: Optional[str] = None,
                 cpu_count: Optional[str] = None,
                 creation_type: Optional[str] = None,
                 custom_attributes: Optional[Sequence[str]] = None,
                 datacenter: Optional[str] = None,
                 datastore: Optional[str] = None,
                 datastore_cluster: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 folder: Optional[str] = None,
                 graceful_shutdown_timeout: Optional[str] = None,
                 hostsystem: Optional[str] = None,
                 memory_size: Optional[str] = None,
                 networks: Optional[Sequence[str]] = None,
                 password: Optional[str] = None,
                 pool: Optional[str] = None,
                 ssh_password: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 ssh_user_group: Optional[str] = None,
                 tags: Optional[Sequence[str]] = None,
                 username: Optional[str] = None,
                 vapp_ip_allocation_policy: Optional[str] = None,
                 vapp_ip_protocol: Optional[str] = None,
                 vapp_properties: Optional[Sequence[str]] = None,
                 vapp_transport: Optional[str] = None,
                 vcenter: Optional[str] = None,
                 vcenter_port: Optional[str] = None):
        """
        :param str boot2docker_url: vSphere URL for boot2docker image
        :param Sequence[str] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param str clone_from: If you choose creation type clone a name of what you want to clone is required
        :param str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param str cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param str content_library: If you choose to clone from a content library template specify the name of the library
        :param str cpu_count: vSphere CPU number for docker VM
        :param str creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param Sequence[str] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param str datacenter: vSphere datacenter for virtual machine
        :param str datastore: vSphere datastore for virtual machine
        :param str datastore_cluster: vSphere datastore cluster for virtual machine
        :param str disk_size: vSphere size of disk for docker VM (in MB)
        :param str folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param 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 str hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        :param str memory_size: vSphere size of memory for docker VM (in MB)
        :param Sequence[str] networks: vSphere network where the virtual machine will be attached
        :param str password: vSphere password
        :param str pool: vSphere resource pool for docker VM
        :param str ssh_password: If using a non-B2D image you can specify the ssh password
        :param str ssh_port: If using a non-B2D image you can specify the ssh port
        :param str ssh_user: If using a non-B2D image you can specify the ssh user
        :param 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[str] tags: vSphere tags id e.g. urn:xxx
        :param str username: vSphere username
        :param str vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param str vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param Sequence[str] vapp_properties: vSphere vApp properties
        :param str vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param str vcenter: vSphere IP/hostname for vCenter
        :param 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[str]:
        """
        vSphere URL for boot2docker image
        """
        return pulumi.get(self, "boot2docker_url")

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[Sequence[str]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[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[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[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[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[str]:
        """
        vSphere CPU number for docker VM
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[str]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[Sequence[str]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[str]:
        """
        vSphere datacenter for virtual machine
        """
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def datastore(self) -> Optional[str]:
        """
        vSphere datastore for virtual machine
        """
        return pulumi.get(self, "datastore")

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[str]:
        """
        vSphere datastore cluster for virtual machine
        """
        return pulumi.get(self, "datastore_cluster")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        vSphere size of disk for docker VM (in MB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[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[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[str]:
        """
        vSphere size of memory for docker VM (in MB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter
    def networks(self) -> Optional[Sequence[str]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        vSphere password
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def pool(self) -> Optional[str]:
        """
        vSphere resource pool for docker VM
        """
        return pulumi.get(self, "pool")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[str]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        vSphere username
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[str]:
        """
        vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[str]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[Sequence[str]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[str]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        """
        return pulumi.get(self, "vapp_transport")

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[str]:
        """
        vSphere IP/hostname for vCenter
        """
        return pulumi.get(self, "vcenter")

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[str]:
        """
        vSphere Port for vCenter
        """
        return pulumi.get(self, "vcenter_port")


@pulumi.output_type
class MultiClusterAppAnswer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clusterId":
            suggest = "cluster_id"
        elif key == "projectId":
            suggest = "project_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppAnswer. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppAnswer.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppAnswer.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 cluster_id: Optional[str] = None,
                 project_id: Optional[str] = None,
                 values: Optional[Mapping[str, Any]] = None):
        """
        :param str cluster_id: Cluster ID for answer
        :param str project_id: Project ID for answer
        :param Mapping[str, Any] values: Key/values for answer
        """
        if cluster_id is not None:
            pulumi.set(__self__, "cluster_id", cluster_id)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> Optional[str]:
        """
        Cluster ID for answer
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[str]:
        """
        Project ID for answer
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def values(self) -> Optional[Mapping[str, Any]]:
        """
        Key/values for answer
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class MultiClusterAppMember(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessType":
            suggest = "access_type"
        elif key == "groupPrincipalId":
            suggest = "group_principal_id"
        elif key == "userPrincipalId":
            suggest = "user_principal_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppMember. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppMember.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppMember.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type: member, owner, read-only
        :param str group_principal_id: Member group principal id
        :param 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[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[str]:
        """
        Member group principal id
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        """
        Member user principal id
        """
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class MultiClusterAppTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectId":
            suggest = "project_id"
        elif key == "appId":
            suggest = "app_id"
        elif key == "healthState":
            suggest = "health_state"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppTarget. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppTarget.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppTarget.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 project_id: str,
                 app_id: Optional[str] = None,
                 health_state: Optional[str] = None,
                 state: Optional[str] = None):
        """
        :param str project_id: Project ID for target
        :param str app_id: App ID for target
        :param str health_state: App health state for target
        :param str state: App state for target
        """
        pulumi.set(__self__, "project_id", project_id)
        if app_id is not None:
            pulumi.set(__self__, "app_id", app_id)
        if health_state is not None:
            pulumi.set(__self__, "health_state", health_state)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        Project ID for target
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> Optional[str]:
        """
        App ID for target
        """
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="healthState")
    def health_state(self) -> Optional[str]:
        """
        App health state for target
        """
        return pulumi.get(self, "health_state")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        App state for target
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class MultiClusterAppUpgradeStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rollingUpdate":
            suggest = "rolling_update"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppUpgradeStrategy. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppUpgradeStrategy.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppUpgradeStrategy.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rolling_update: Optional['outputs.MultiClusterAppUpgradeStrategyRollingUpdate'] = None):
        """
        :param 'MultiClusterAppUpgradeStrategyRollingUpdateArgs' rolling_update: Rolling update for upgrade strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.MultiClusterAppUpgradeStrategyRollingUpdate']:
        """
        Rolling update for upgrade strategy
        """
        return pulumi.get(self, "rolling_update")


@pulumi.output_type
class MultiClusterAppUpgradeStrategyRollingUpdate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "batchSize":
            suggest = "batch_size"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in MultiClusterAppUpgradeStrategyRollingUpdate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        MultiClusterAppUpgradeStrategyRollingUpdate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        MultiClusterAppUpgradeStrategyRollingUpdate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 batch_size: Optional[int] = None,
                 interval: Optional[int] = None):
        """
        :param int batch_size: Rolling update batch size
        :param int interval: Rolling update interval
        """
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)

    @property
    @pulumi.getter(name="batchSize")
    def batch_size(self) -> Optional[int]:
        """
        Rolling update batch size
        """
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        Rolling update interval
        """
        return pulumi.get(self, "interval")


@pulumi.output_type
class NamespaceContainerResourceLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NamespaceContainerResourceLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NamespaceContainerResourceLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NamespaceContainerResourceLimit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class NamespaceResourceQuota(dict):
    def __init__(__self__, *,
                 limit: 'outputs.NamespaceResourceQuotaLimit'):
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> 'outputs.NamespaceResourceQuotaLimit':
        return pulumi.get(self, "limit")


@pulumi.output_type
class NamespaceResourceQuotaLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NamespaceResourceQuotaLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NamespaceResourceQuotaLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NamespaceResourceQuotaLimit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class NodePoolNodeTaint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeAdded":
            suggest = "time_added"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeTaint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodePoolNodeTaint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodePoolNodeTaint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None,
                 time_added: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if time_added is not None:
            pulumi.set(__self__, "time_added", time_added)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[str]:
        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: str,
                 region: str,
                 security_groups: Sequence[str],
                 subnet_id: str,
                 vpc_id: str,
                 zone: str,
                 access_key: Optional[str] = None,
                 block_duration_minutes: Optional[str] = None,
                 device_name: Optional[str] = None,
                 encrypt_ebs_volume: Optional[bool] = None,
                 endpoint: Optional[str] = None,
                 http_endpoint: Optional[str] = None,
                 http_tokens: Optional[str] = None,
                 iam_instance_profile: Optional[str] = None,
                 insecure_transport: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 kms_key: Optional[str] = None,
                 monitoring: Optional[bool] = None,
                 open_ports: Optional[Sequence[str]] = None,
                 private_address_only: Optional[bool] = None,
                 request_spot_instance: Optional[bool] = None,
                 retries: Optional[str] = None,
                 root_size: Optional[str] = None,
                 secret_key: Optional[str] = None,
                 security_group_readonly: Optional[bool] = None,
                 session_token: Optional[str] = None,
                 spot_price: Optional[str] = None,
                 ssh_keypath: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 use_ebs_optimized_instance: Optional[bool] = None,
                 use_private_address: Optional[bool] = None,
                 userdata: Optional[str] = None,
                 volume_type: Optional[str] = None):
        """
        :param str ami: AWS machine image
        :param str region: AWS Region
        :param Sequence[str] security_groups: AWS VPC security group
        :param str subnet_id: AWS VPC subnet id
        :param str vpc_id: AWS VPC id
        :param str zone: AWS zone for instance (i.e. a,b,c,d,e)
        :param str access_key: AWS Access Key
        :param str block_duration_minutes: AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        :param str device_name: AWS root device name
        :param bool encrypt_ebs_volume: Encrypt EBS volume
        :param str endpoint: Optional endpoint URL (hostname only or fully qualified URI)
        :param str http_endpoint: Enables or disables the HTTP metadata endpoint on your instances
        :param str http_tokens: The state of token usage for your instance metadata requests
        :param str iam_instance_profile: AWS IAM Instance Profile
        :param bool insecure_transport: Disable SSL when sending requests
        :param str instance_type: AWS instance type
        :param str kms_key: Custom KMS key ID using the AWS Managed CMK
        :param bool monitoring: Set this flag to enable CloudWatch monitoring
        :param Sequence[str] open_ports: Make the specified port number accessible from the Internet
        :param bool private_address_only: Only use a private IP address
        :param bool request_spot_instance: Set this flag to request spot instance
        :param str retries: Set retry count for recoverable failures (use -1 to disable)
        :param str root_size: AWS root disk size (in GB)
        :param str secret_key: AWS Secret Key
        :param bool security_group_readonly: Skip adding default rules to security groups
        :param str session_token: AWS Session Token
        :param str spot_price: AWS spot instance bid price (in dollar)
        :param str ssh_keypath: SSH Key for Instance
        :param str ssh_user: Set the name of the ssh user
        :param str tags: AWS Tags (e.g. key1,value1,key2,value2)
        :param bool use_ebs_optimized_instance: Create an EBS optimized instance
        :param bool use_private_address: Force the usage of private IP address
        :param str userdata: Path to file with cloud-init user data
        :param 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) -> str:
        """
        AWS machine image
        """
        return pulumi.get(self, "ami")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        AWS Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="securityGroups")
    def security_groups(self) -> Sequence[str]:
        """
        AWS VPC security group
        """
        return pulumi.get(self, "security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        """
        AWS VPC subnet id
        """
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="vpcId")
    def vpc_id(self) -> str:
        """
        AWS VPC id
        """
        return pulumi.get(self, "vpc_id")

    @property
    @pulumi.getter
    def zone(self) -> 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[str]:
        """
        AWS Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="blockDurationMinutes")
    def block_duration_minutes(self) -> Optional[str]:
        """
        AWS spot instance duration in minutes (60, 120, 180, 240, 300, or 360)
        """
        return pulumi.get(self, "block_duration_minutes")

    @property
    @pulumi.getter(name="deviceName")
    def device_name(self) -> Optional[str]:
        """
        AWS root device name
        """
        return pulumi.get(self, "device_name")

    @property
    @pulumi.getter(name="encryptEbsVolume")
    def encrypt_ebs_volume(self) -> Optional[bool]:
        """
        Encrypt EBS volume
        """
        return pulumi.get(self, "encrypt_ebs_volume")

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[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[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[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[str]:
        """
        AWS IAM Instance Profile
        """
        return pulumi.get(self, "iam_instance_profile")

    @property
    @pulumi.getter(name="insecureTransport")
    def insecure_transport(self) -> Optional[bool]:
        """
        Disable SSL when sending requests
        """
        return pulumi.get(self, "insecure_transport")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        AWS instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[str]:
        """
        Custom KMS key ID using the AWS Managed CMK
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Set this flag to enable CloudWatch monitoring
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="openPorts")
    def open_ports(self) -> Optional[Sequence[str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter(name="privateAddressOnly")
    def private_address_only(self) -> Optional[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[bool]:
        """
        Set this flag to request spot instance
        """
        return pulumi.get(self, "request_spot_instance")

    @property
    @pulumi.getter
    def retries(self) -> Optional[str]:
        """
        Set retry count for recoverable failures (use -1 to disable)
        """
        return pulumi.get(self, "retries")

    @property
    @pulumi.getter(name="rootSize")
    def root_size(self) -> Optional[str]:
        """
        AWS root disk size (in GB)
        """
        return pulumi.get(self, "root_size")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        """
        AWS Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="securityGroupReadonly")
    def security_group_readonly(self) -> Optional[bool]:
        """
        Skip adding default rules to security groups
        """
        return pulumi.get(self, "security_group_readonly")

    @property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[str]:
        """
        AWS Session Token
        """
        return pulumi.get(self, "session_token")

    @property
    @pulumi.getter(name="spotPrice")
    def spot_price(self) -> Optional[str]:
        """
        AWS spot instance bid price (in dollar)
        """
        return pulumi.get(self, "spot_price")

    @property
    @pulumi.getter(name="sshKeypath")
    def ssh_keypath(self) -> Optional[str]:
        """
        SSH Key for Instance
        """
        return pulumi.get(self, "ssh_keypath")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        Set the name of the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[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[bool]:
        """
        Force the usage of private IP address
        """
        return pulumi.get(self, "use_private_address")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[str]:
        """
        Path to file with cloud-init user data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[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[bool] = None,
                 availability_set: Optional[str] = None,
                 availability_zone: Optional[str] = None,
                 client_id: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 custom_data: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 dns: Optional[str] = None,
                 docker_port: Optional[str] = None,
                 environment: Optional[str] = None,
                 fault_domain_count: Optional[str] = None,
                 image: Optional[str] = None,
                 location: Optional[str] = None,
                 managed_disks: Optional[bool] = None,
                 no_public_ip: Optional[bool] = None,
                 nsg: Optional[str] = None,
                 open_ports: Optional[Sequence[str]] = None,
                 plan: Optional[str] = None,
                 private_ip_address: Optional[str] = None,
                 resource_group: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 static_public_ip: Optional[bool] = None,
                 storage_type: Optional[str] = None,
                 subnet: Optional[str] = None,
                 subnet_prefix: Optional[str] = None,
                 subscription_id: Optional[str] = None,
                 tags: Optional[str] = None,
                 update_domain_count: Optional[str] = None,
                 use_private_ip: Optional[bool] = None,
                 use_public_ip_standard_sku: Optional[bool] = None,
                 vnet: Optional[str] = None):
        """
        :param bool accelerated_networking: Enable Accelerated Networking when creating an Azure Network Interface
        :param str availability_set: Azure Availability Set to place the virtual machine into
        :param str availability_zone: The Azure Availability Zone the VM should be created in
        :param str client_id: Azure Service Principal Account ID (optional, browser auth is used if not specified)
        :param str client_secret: Azure Service Principal Account password (optional, browser auth is used if not specified)
        :param str custom_data: Path to file with custom-data
        :param str disk_size: Disk size if using managed disk
        :param str dns: A unique DNS label for the public IP adddress
        :param str docker_port: Port number for Docker engine
        :param str environment: Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        :param str fault_domain_count: Fault domain count to use for availability set
        :param str image: Azure virtual machine OS image
        :param str location: Azure region to create the virtual machine
        :param bool managed_disks: Configures VM and availability set for managed disks
        :param bool no_public_ip: Do not create a public IP address for the machine
        :param str nsg: Azure Network Security Group to assign this node to (accepts either a name or resource ID, default is to create a new NSG for each machine)
        :param Sequence[str] open_ports: Make the specified port number accessible from the Internet
        :param str plan: Purchase plan for Azure Virtual Machine (in <publisher>:<product>:<plan> format)
        :param str private_ip_address: Specify a static private IP address for the machine
        :param str resource_group: Azure Resource Group name (will be created if missing)
        :param str size: Size for Azure Virtual Machine
        :param str ssh_user: Username for SSH login
        :param bool static_public_ip: Assign a static public IP address to the machine
        :param str storage_type: Type of Storage Account to host the OS Disk for the machine
        :param str subnet: Azure Subnet Name to be used within the Virtual Network
        :param str subnet_prefix: Private CIDR block to be used for the new subnet, should comply RFC 1918
        :param str subscription_id: Azure Subscription ID
        :param str tags: Tags to be applied to the Azure VM instance (e.g. key1,value1,key2,value2)
        :param str update_domain_count: Update domain count to use for availability set
        :param bool use_private_ip: Use private IP address of the machine to connect
        :param bool use_public_ip_standard_sku: Use the Standard SKU when creating a public IP for an Azure VM
        :param 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[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[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[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[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[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[str]:
        """
        Path to file with custom-data
        """
        return pulumi.get(self, "custom_data")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        Disk size if using managed disk
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def dns(self) -> Optional[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[str]:
        """
        Port number for Docker engine
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def environment(self) -> Optional[str]:
        """
        Azure environment (e.g. AzurePublicCloud, AzureChinaCloud)
        """
        return pulumi.get(self, "environment")

    @property
    @pulumi.getter(name="faultDomainCount")
    def fault_domain_count(self) -> Optional[str]:
        """
        Fault domain count to use for availability set
        """
        return pulumi.get(self, "fault_domain_count")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Azure virtual machine OS image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def location(self) -> Optional[str]:
        """
        Azure region to create the virtual machine
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="managedDisks")
    def managed_disks(self) -> Optional[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[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[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[str]]:
        """
        Make the specified port number accessible from the Internet
        """
        return pulumi.get(self, "open_ports")

    @property
    @pulumi.getter
    def plan(self) -> Optional[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[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[str]:
        """
        Azure Resource Group name (will be created if missing)
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Size for Azure Virtual Machine
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        Username for SSH login
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="staticPublicIp")
    def static_public_ip(self) -> Optional[bool]:
        """
        Assign a static public IP address to the machine
        """
        return pulumi.get(self, "static_public_ip")

    @property
    @pulumi.getter(name="storageType")
    def storage_type(self) -> Optional[str]:
        """
        Type of Storage Account to host the OS Disk for the machine
        """
        return pulumi.get(self, "storage_type")

    @property
    @pulumi.getter
    def subnet(self) -> Optional[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[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[str]:
        """
        Azure Subscription ID
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[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[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[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[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[str] = None,
                 backups: Optional[bool] = None,
                 image: Optional[str] = None,
                 ipv6: Optional[bool] = None,
                 monitoring: Optional[bool] = None,
                 private_networking: Optional[bool] = None,
                 region: Optional[str] = None,
                 size: Optional[str] = None,
                 ssh_key_fingerprint: Optional[str] = None,
                 ssh_key_path: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tags: Optional[str] = None,
                 userdata: Optional[str] = None):
        """
        :param str access_token: Digital Ocean access token
        :param bool backups: Enable backups for droplet
        :param str image: Digital Ocean Image
        :param bool ipv6: Enable ipv6 for droplet
        :param bool monitoring: Enable monitoring for droplet
        :param bool private_networking: Enable private networking for droplet
        :param str region: Digital Ocean region
        :param str size: Digital Ocean size
        :param str ssh_key_fingerprint: SSH key fingerprint
        :param str ssh_key_path: SSH private key path
        :param str ssh_port: SSH port
        :param str ssh_user: SSH username
        :param str tags: Comma-separated list of tags to apply to the Droplet
        :param 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[str]:
        """
        Digital Ocean access token
        """
        return pulumi.get(self, "access_token")

    @property
    @pulumi.getter
    def backups(self) -> Optional[bool]:
        """
        Enable backups for droplet
        """
        return pulumi.get(self, "backups")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Digital Ocean Image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def ipv6(self) -> Optional[bool]:
        """
        Enable ipv6 for droplet
        """
        return pulumi.get(self, "ipv6")

    @property
    @pulumi.getter
    def monitoring(self) -> Optional[bool]:
        """
        Enable monitoring for droplet
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter(name="privateNetworking")
    def private_networking(self) -> Optional[bool]:
        """
        Enable private networking for droplet
        """
        return pulumi.get(self, "private_networking")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Digital Ocean region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def size(self) -> Optional[str]:
        """
        Digital Ocean size
        """
        return pulumi.get(self, "size")

    @property
    @pulumi.getter(name="sshKeyFingerprint")
    def ssh_key_fingerprint(self) -> Optional[str]:
        """
        SSH key fingerprint
        """
        return pulumi.get(self, "ssh_key_fingerprint")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> Optional[str]:
        """
        SSH private key path
        """
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        SSH port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter
    def tags(self) -> Optional[str]:
        """
        Comma-separated list of tags to apply to the Droplet
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[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: str,
                 vm_namespace: str,
                 cpu_count: Optional[str] = None,
                 disk_bus: Optional[str] = None,
                 disk_info: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 image_name: Optional[str] = None,
                 memory_size: Optional[str] = None,
                 network_data: Optional[str] = None,
                 network_info: Optional[str] = None,
                 network_model: Optional[str] = None,
                 network_name: Optional[str] = None,
                 ssh_password: Optional[str] = None,
                 user_data: Optional[str] = None,
                 vm_affinity: Optional[str] = None):
        """
        :param str ssh_user: SSH username
        :param str vm_namespace: Virtual machine namespace
        :param str cpu_count: CPU count
        :param str disk_bus: Disk bus
        :param 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 str disk_size: Disk size (in GiB)
        :param str image_name: Image name
        :param str memory_size: Memory size (in GiB)
        :param str network_data: NetworkData content of cloud-init, base64 is supported
        :param str network_info: A JSON string specifying info for the networks e.g. `{"interfaces":[{"networkName":"harvester-public/vlan1"},{"networkName":"harvester-public/vlan2"}]}`
        :param str network_model: Network model
        :param str network_name: Network name
        :param str ssh_password: SSH password
        :param 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 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) -> str:
        """
        SSH username
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="vmNamespace")
    def vm_namespace(self) -> str:
        """
        Virtual machine namespace
        """
        return pulumi.get(self, "vm_namespace")

    @property
    @pulumi.getter(name="cpuCount")
    def cpu_count(self) -> Optional[str]:
        """
        CPU count
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="diskBus")
    def disk_bus(self) -> Optional[str]:
        """
        Disk bus
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_bus is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_bus")

    @property
    @pulumi.getter(name="diskInfo")
    def disk_info(self) -> Optional[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")
    def disk_size(self) -> Optional[str]:
        """
        Disk size (in GiB)
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""disk_size is deprecated: Use disk_info instead""")

        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        """
        Image name
        """
        warnings.warn("""Use disk_info instead""", DeprecationWarning)
        pulumi.log.warn("""image_name is deprecated: Use disk_info instead""")

        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="memorySize")
    def memory_size(self) -> Optional[str]:
        """
        Memory size (in GiB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter(name="networkData")
    def network_data(self) -> Optional[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[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")
    def network_model(self) -> Optional[str]:
        """
        Network model
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_model is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_model")

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[str]:
        """
        Network name
        """
        warnings.warn("""Use network_info instead""", DeprecationWarning)
        pulumi.log.warn("""network_name is deprecated: Use network_info instead""")

        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[str]:
        """
        SSH password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> Optional[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[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: str,
                 image: Optional[str] = None,
                 networks: Optional[str] = None,
                 server_labels: Optional[Mapping[str, Any]] = None,
                 server_location: Optional[str] = None,
                 server_type: Optional[str] = None,
                 use_private_network: Optional[bool] = None,
                 userdata: Optional[str] = None,
                 volumes: Optional[str] = None):
        """
        :param str api_token: Hetzner Cloud project API token
        :param str image: Hetzner Cloud server image
        :param str networks: Comma-separated list of network IDs or names which should be attached to the server private network interface
        :param Mapping[str, Any] server_labels: Map of the labels which will be assigned to the server
        :param str server_location: Hetzner Cloud datacenter
        :param str server_type: Hetzner Cloud server type
        :param bool use_private_network: Use private network
        :param str userdata: Path to file with cloud-init user-data
        :param 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) -> str:
        """
        Hetzner Cloud project API token
        """
        return pulumi.get(self, "api_token")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Hetzner Cloud server image
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def networks(self) -> Optional[str]:
        """
        Comma-separated list of network IDs or names which should be attached to the server private network interface
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter(name="serverLabels")
    def server_labels(self) -> Optional[Mapping[str, Any]]:
        """
        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[str]:
        """
        Hetzner Cloud datacenter
        """
        return pulumi.get(self, "server_location")

    @property
    @pulumi.getter(name="serverType")
    def server_type(self) -> Optional[str]:
        """
        Hetzner Cloud server type
        """
        return pulumi.get(self, "server_type")

    @property
    @pulumi.getter(name="usePrivateNetwork")
    def use_private_network(self) -> Optional[bool]:
        """
        Use private network
        """
        return pulumi.get(self, "use_private_network")

    @property
    @pulumi.getter
    def userdata(self) -> Optional[str]:
        """
        Path to file with cloud-init user-data
        """
        return pulumi.get(self, "userdata")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[str]:
        """
        Comma-separated list of volume IDs or names which should be attached to the server
        """
        return pulumi.get(self, "volumes")


@pulumi.output_type
class NodeTemplateLinodeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authorizedUsers":
            suggest = "authorized_users"
        elif key == "createPrivateIp":
            suggest = "create_private_ip"
        elif key == "dockerPort":
            suggest = "docker_port"
        elif key == "instanceType":
            suggest = "instance_type"
        elif key == "rootPass":
            suggest = "root_pass"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "stackscriptData":
            suggest = "stackscript_data"
        elif key == "swapSize":
            suggest = "swap_size"
        elif key == "uaPrefix":
            suggest = "ua_prefix"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateLinodeConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateLinodeConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateLinodeConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 authorized_users: Optional[str] = None,
                 create_private_ip: Optional[bool] = None,
                 docker_port: Optional[str] = None,
                 image: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 label: Optional[str] = None,
                 region: Optional[str] = None,
                 root_pass: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 stackscript: Optional[str] = None,
                 stackscript_data: Optional[str] = None,
                 swap_size: Optional[str] = None,
                 tags: Optional[str] = None,
                 token: Optional[str] = None,
                 ua_prefix: Optional[str] = None):
        """
        :param str authorized_users: Linode user accounts (seperated by commas) whose Linode SSH keys will be permitted root access to the created node
        :param bool create_private_ip: Create private IP for the instance
        :param str docker_port: Docker Port
        :param str image: Specifies the Linode Instance image which determines the OS distribution and base files
        :param str instance_type: Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        :param str label: Linode Instance Label
        :param str region: Specifies the region (location) of the Linode instance
        :param str root_pass: Root Password
        :param str ssh_port: Linode Instance SSH Port
        :param str ssh_user: Specifies the user as which docker-machine should log in to the Linode instance to install Docker.
        :param str stackscript: Specifies the Linode StackScript to use to create the instance
        :param str stackscript_data: A JSON string specifying data for the selected StackScript
        :param str swap_size: Linode Instance Swap Size (MB)
        :param str tags: A comma separated list of tags to apply to the the Linode resource
        :param str token: Linode API Token
        :param 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[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[bool]:
        """
        Create private IP for the instance
        """
        return pulumi.get(self, "create_private_ip")

    @property
    @pulumi.getter(name="dockerPort")
    def docker_port(self) -> Optional[str]:
        """
        Docker Port
        """
        return pulumi.get(self, "docker_port")

    @property
    @pulumi.getter
    def image(self) -> Optional[str]:
        """
        Specifies the Linode Instance image which determines the OS distribution and base files
        """
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        Specifies the Linode Instance type which determines CPU, memory, disk size, etc.
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def label(self) -> Optional[str]:
        """
        Linode Instance Label
        """
        return pulumi.get(self, "label")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Specifies the region (location) of the Linode instance
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootPass")
    def root_pass(self) -> Optional[str]:
        """
        Root Password
        """
        return pulumi.get(self, "root_pass")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        Linode Instance SSH Port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[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[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[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[str]:
        """
        Linode Instance Swap Size (MB)
        """
        return pulumi.get(self, "swap_size")

    @property
    @pulumi.getter
    def tags(self) -> Optional[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[str]:
        """
        Linode API Token
        """
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="uaPrefix")
    def ua_prefix(self) -> Optional[str]:
        """
        Prefix the User-Agent in Linode API calls with some 'product/version'
        """
        return pulumi.get(self, "ua_prefix")


@pulumi.output_type
class NodeTemplateNodeTaint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "timeAdded":
            suggest = "time_added"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateNodeTaint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateNodeTaint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateNodeTaint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None,
                 time_added: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if time_added is not None:
            pulumi.set(__self__, "time_added", time_added)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> Optional[str]:
        return pulumi.get(self, "time_added")


@pulumi.output_type
class NodeTemplateOpennebulaConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "xmlRpcUrl":
            suggest = "xml_rpc_url"
        elif key == "b2dSize":
            suggest = "b2d_size"
        elif key == "devPrefix":
            suggest = "dev_prefix"
        elif key == "disableVnc":
            suggest = "disable_vnc"
        elif key == "diskResize":
            suggest = "disk_resize"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "imageOwner":
            suggest = "image_owner"
        elif key == "networkId":
            suggest = "network_id"
        elif key == "networkName":
            suggest = "network_name"
        elif key == "networkOwner":
            suggest = "network_owner"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "templateId":
            suggest = "template_id"
        elif key == "templateName":
            suggest = "template_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateOpennebulaConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateOpennebulaConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateOpennebulaConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 password: str,
                 user: str,
                 xml_rpc_url: str,
                 b2d_size: Optional[str] = None,
                 cpu: Optional[str] = None,
                 dev_prefix: Optional[str] = None,
                 disable_vnc: Optional[bool] = None,
                 disk_resize: Optional[str] = None,
                 image_id: Optional[str] = None,
                 image_name: Optional[str] = None,
                 image_owner: Optional[str] = None,
                 memory: Optional[str] = None,
                 network_id: Optional[str] = None,
                 network_name: Optional[str] = None,
                 network_owner: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 template_id: Optional[str] = None,
                 template_name: Optional[str] = None,
                 vcpu: Optional[str] = None):
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "user", user)
        pulumi.set(__self__, "xml_rpc_url", xml_rpc_url)
        if b2d_size is not None:
            pulumi.set(__self__, "b2d_size", b2d_size)
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if dev_prefix is not None:
            pulumi.set(__self__, "dev_prefix", dev_prefix)
        if disable_vnc is not None:
            pulumi.set(__self__, "disable_vnc", disable_vnc)
        if disk_resize is not None:
            pulumi.set(__self__, "disk_resize", disk_resize)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if image_owner is not None:
            pulumi.set(__self__, "image_owner", image_owner)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)
        if network_id is not None:
            pulumi.set(__self__, "network_id", network_id)
        if network_name is not None:
            pulumi.set(__self__, "network_name", network_name)
        if network_owner is not None:
            pulumi.set(__self__, "network_owner", network_owner)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)
        if template_name is not None:
            pulumi.set(__self__, "template_name", template_name)
        if vcpu is not None:
            pulumi.set(__self__, "vcpu", vcpu)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="xmlRpcUrl")
    def xml_rpc_url(self) -> str:
        return pulumi.get(self, "xml_rpc_url")

    @property
    @pulumi.getter(name="b2dSize")
    def b2d_size(self) -> Optional[str]:
        return pulumi.get(self, "b2d_size")

    @property
    @pulumi.getter
    def cpu(self) -> Optional[str]:
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter(name="devPrefix")
    def dev_prefix(self) -> Optional[str]:
        return pulumi.get(self, "dev_prefix")

    @property
    @pulumi.getter(name="disableVnc")
    def disable_vnc(self) -> Optional[bool]:
        return pulumi.get(self, "disable_vnc")

    @property
    @pulumi.getter(name="diskResize")
    def disk_resize(self) -> Optional[str]:
        return pulumi.get(self, "disk_resize")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter(name="imageOwner")
    def image_owner(self) -> Optional[str]:
        return pulumi.get(self, "image_owner")

    @property
    @pulumi.getter
    def memory(self) -> Optional[str]:
        return pulumi.get(self, "memory")

    @property
    @pulumi.getter(name="networkId")
    def network_id(self) -> Optional[str]:
        return pulumi.get(self, "network_id")

    @property
    @pulumi.getter(name="networkName")
    def network_name(self) -> Optional[str]:
        return pulumi.get(self, "network_name")

    @property
    @pulumi.getter(name="networkOwner")
    def network_owner(self) -> Optional[str]:
        return pulumi.get(self, "network_owner")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> Optional[str]:
        return pulumi.get(self, "template_id")

    @property
    @pulumi.getter(name="templateName")
    def template_name(self) -> Optional[str]:
        return pulumi.get(self, "template_name")

    @property
    @pulumi.getter
    def vcpu(self) -> Optional[str]:
        return pulumi.get(self, "vcpu")


@pulumi.output_type
class NodeTemplateOpenstackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "authUrl":
            suggest = "auth_url"
        elif key == "availabilityZone":
            suggest = "availability_zone"
        elif key == "activeTimeout":
            suggest = "active_timeout"
        elif key == "applicationCredentialId":
            suggest = "application_credential_id"
        elif key == "applicationCredentialName":
            suggest = "application_credential_name"
        elif key == "applicationCredentialSecret":
            suggest = "application_credential_secret"
        elif key == "bootFromVolume":
            suggest = "boot_from_volume"
        elif key == "configDrive":
            suggest = "config_drive"
        elif key == "domainId":
            suggest = "domain_id"
        elif key == "domainName":
            suggest = "domain_name"
        elif key == "endpointType":
            suggest = "endpoint_type"
        elif key == "flavorId":
            suggest = "flavor_id"
        elif key == "flavorName":
            suggest = "flavor_name"
        elif key == "floatingIpPool":
            suggest = "floating_ip_pool"
        elif key == "imageId":
            suggest = "image_id"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "ipVersion":
            suggest = "ip_version"
        elif key == "keypairName":
            suggest = "keypair_name"
        elif key == "netId":
            suggest = "net_id"
        elif key == "netName":
            suggest = "net_name"
        elif key == "novaNetwork":
            suggest = "nova_network"
        elif key == "privateKeyFile":
            suggest = "private_key_file"
        elif key == "secGroups":
            suggest = "sec_groups"
        elif key == "sshPort":
            suggest = "ssh_port"
        elif key == "sshUser":
            suggest = "ssh_user"
        elif key == "tenantId":
            suggest = "tenant_id"
        elif key == "tenantName":
            suggest = "tenant_name"
        elif key == "userDataFile":
            suggest = "user_data_file"
        elif key == "volumeDevicePath":
            suggest = "volume_device_path"
        elif key == "volumeId":
            suggest = "volume_id"
        elif key == "volumeName":
            suggest = "volume_name"
        elif key == "volumeSize":
            suggest = "volume_size"
        elif key == "volumeType":
            suggest = "volume_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NodeTemplateOpenstackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NodeTemplateOpenstackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NodeTemplateOpenstackConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 auth_url: str,
                 availability_zone: str,
                 region: str,
                 active_timeout: Optional[str] = None,
                 application_credential_id: Optional[str] = None,
                 application_credential_name: Optional[str] = None,
                 application_credential_secret: Optional[str] = None,
                 boot_from_volume: Optional[bool] = None,
                 cacert: Optional[str] = None,
                 config_drive: Optional[bool] = None,
                 domain_id: Optional[str] = None,
                 domain_name: Optional[str] = None,
                 endpoint_type: Optional[str] = None,
                 flavor_id: Optional[str] = None,
                 flavor_name: Optional[str] = None,
                 floating_ip_pool: Optional[str] = None,
                 image_id: Optional[str] = None,
                 image_name: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 ip_version: Optional[str] = None,
                 keypair_name: Optional[str] = None,
                 net_id: Optional[str] = None,
                 net_name: Optional[str] = None,
                 nova_network: Optional[bool] = None,
                 password: Optional[str] = None,
                 private_key_file: Optional[str] = None,
                 sec_groups: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 tenant_id: Optional[str] = None,
                 tenant_name: Optional[str] = None,
                 user_data_file: Optional[str] = None,
                 username: Optional[str] = None,
                 volume_device_path: Optional[str] = None,
                 volume_id: Optional[str] = None,
                 volume_name: Optional[str] = None,
                 volume_size: Optional[str] = None,
                 volume_type: Optional[str] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "availability_zone", availability_zone)
        pulumi.set(__self__, "region", region)
        if active_timeout is not None:
            pulumi.set(__self__, "active_timeout", active_timeout)
        if application_credential_id is not None:
            pulumi.set(__self__, "application_credential_id", application_credential_id)
        if application_credential_name is not None:
            pulumi.set(__self__, "application_credential_name", application_credential_name)
        if application_credential_secret is not None:
            pulumi.set(__self__, "application_credential_secret", application_credential_secret)
        if boot_from_volume is not None:
            pulumi.set(__self__, "boot_from_volume", boot_from_volume)
        if cacert is not None:
            pulumi.set(__self__, "cacert", cacert)
        if config_drive is not None:
            pulumi.set(__self__, "config_drive", config_drive)
        if domain_id is not None:
            pulumi.set(__self__, "domain_id", domain_id)
        if domain_name is not None:
            pulumi.set(__self__, "domain_name", domain_name)
        if endpoint_type is not None:
            pulumi.set(__self__, "endpoint_type", endpoint_type)
        if flavor_id is not None:
            pulumi.set(__self__, "flavor_id", flavor_id)
        if flavor_name is not None:
            pulumi.set(__self__, "flavor_name", flavor_name)
        if floating_ip_pool is not None:
            pulumi.set(__self__, "floating_ip_pool", floating_ip_pool)
        if image_id is not None:
            pulumi.set(__self__, "image_id", image_id)
        if image_name is not None:
            pulumi.set(__self__, "image_name", image_name)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if ip_version is not None:
            pulumi.set(__self__, "ip_version", ip_version)
        if keypair_name is not None:
            pulumi.set(__self__, "keypair_name", keypair_name)
        if net_id is not None:
            pulumi.set(__self__, "net_id", net_id)
        if net_name is not None:
            pulumi.set(__self__, "net_name", net_name)
        if nova_network is not None:
            pulumi.set(__self__, "nova_network", nova_network)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if private_key_file is not None:
            pulumi.set(__self__, "private_key_file", private_key_file)
        if sec_groups is not None:
            pulumi.set(__self__, "sec_groups", sec_groups)
        if ssh_port is not None:
            pulumi.set(__self__, "ssh_port", ssh_port)
        if ssh_user is not None:
            pulumi.set(__self__, "ssh_user", ssh_user)
        if tenant_id is not None:
            pulumi.set(__self__, "tenant_id", tenant_id)
        if tenant_name is not None:
            pulumi.set(__self__, "tenant_name", tenant_name)
        if user_data_file is not None:
            pulumi.set(__self__, "user_data_file", user_data_file)
        if username is not None:
            pulumi.set(__self__, "username", username)
        if volume_device_path is not None:
            pulumi.set(__self__, "volume_device_path", volume_device_path)
        if volume_id is not None:
            pulumi.set(__self__, "volume_id", volume_id)
        if volume_name is not None:
            pulumi.set(__self__, "volume_name", volume_name)
        if volume_size is not None:
            pulumi.set(__self__, "volume_size", volume_size)
        if volume_type is not None:
            pulumi.set(__self__, "volume_type", volume_type)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> str:
        return pulumi.get(self, "availability_zone")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="activeTimeout")
    def active_timeout(self) -> Optional[str]:
        return pulumi.get(self, "active_timeout")

    @property
    @pulumi.getter(name="applicationCredentialId")
    def application_credential_id(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_id")

    @property
    @pulumi.getter(name="applicationCredentialName")
    def application_credential_name(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_name")

    @property
    @pulumi.getter(name="applicationCredentialSecret")
    def application_credential_secret(self) -> Optional[str]:
        return pulumi.get(self, "application_credential_secret")

    @property
    @pulumi.getter(name="bootFromVolume")
    def boot_from_volume(self) -> Optional[bool]:
        return pulumi.get(self, "boot_from_volume")

    @property
    @pulumi.getter
    def cacert(self) -> Optional[str]:
        return pulumi.get(self, "cacert")

    @property
    @pulumi.getter(name="configDrive")
    def config_drive(self) -> Optional[bool]:
        return pulumi.get(self, "config_drive")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> Optional[str]:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> Optional[str]:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter(name="endpointType")
    def endpoint_type(self) -> Optional[str]:
        return pulumi.get(self, "endpoint_type")

    @property
    @pulumi.getter(name="flavorId")
    def flavor_id(self) -> Optional[str]:
        return pulumi.get(self, "flavor_id")

    @property
    @pulumi.getter(name="flavorName")
    def flavor_name(self) -> Optional[str]:
        return pulumi.get(self, "flavor_name")

    @property
    @pulumi.getter(name="floatingIpPool")
    def floating_ip_pool(self) -> Optional[str]:
        return pulumi.get(self, "floating_ip_pool")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> Optional[str]:
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="ipVersion")
    def ip_version(self) -> Optional[str]:
        return pulumi.get(self, "ip_version")

    @property
    @pulumi.getter(name="keypairName")
    def keypair_name(self) -> Optional[str]:
        return pulumi.get(self, "keypair_name")

    @property
    @pulumi.getter(name="netId")
    def net_id(self) -> Optional[str]:
        return pulumi.get(self, "net_id")

    @property
    @pulumi.getter(name="netName")
    def net_name(self) -> Optional[str]:
        return pulumi.get(self, "net_name")

    @property
    @pulumi.getter(name="novaNetwork")
    def nova_network(self) -> Optional[bool]:
        return pulumi.get(self, "nova_network")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter(name="privateKeyFile")
    def private_key_file(self) -> Optional[str]:
        return pulumi.get(self, "private_key_file")

    @property
    @pulumi.getter(name="secGroups")
    def sec_groups(self) -> Optional[str]:
        return pulumi.get(self, "sec_groups")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> Optional[str]:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> Optional[str]:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="userDataFile")
    def user_data_file(self) -> Optional[str]:
        return pulumi.get(self, "user_data_file")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="volumeDevicePath")
    def volume_device_path(self) -> Optional[str]:
        return pulumi.get(self, "volume_device_path")

    @property
    @pulumi.getter(name="volumeId")
    def volume_id(self) -> Optional[str]:
        return pulumi.get(self, "volume_id")

    @property
    @pulumi.getter(name="volumeName")
    def volume_name(self) -> Optional[str]:
        return pulumi.get(self, "volume_name")

    @property
    @pulumi.getter(name="volumeSize")
    def volume_size(self) -> Optional[str]:
        return pulumi.get(self, "volume_size")

    @property
    @pulumi.getter(name="volumeType")
    def volume_type(self) -> Optional[str]:
        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: str,
                 secret_key: str,
                 extra_tags_alls: Optional[Sequence[str]] = None,
                 extra_tags_instances: Optional[Sequence[str]] = None,
                 instance_type: Optional[str] = None,
                 region: Optional[str] = None,
                 root_disk_iops: Optional[int] = None,
                 root_disk_size: Optional[int] = None,
                 root_disk_type: Optional[str] = None,
                 security_group_ids: Optional[Sequence[str]] = None,
                 source_omi: Optional[str] = None):
        """
        :param str access_key: Outscale Access Key
        :param str secret_key: Outscale Secret Key
        :param Sequence[str] extra_tags_alls: Extra tags for all created resources (e.g. key1=value1,key2=value2)
        :param Sequence[str] extra_tags_instances: Extra tags only for instances (e.g. key1=value1,key2=value2)
        :param str instance_type: Outscale VM type
        :param str region: Outscale Region
        :param int root_disk_iops: Iops for io1 Root Disk. From 1 to 13000.
        :param int root_disk_size: Size of the Root Disk (in GB). From 1 to 14901.
        :param str root_disk_type: Type of the Root Disk. Possible values are :'standard', 'gp2' or 'io1'.
        :param Sequence[str] security_group_ids: Ids of user defined Security Groups to add to the machine
        :param 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) -> str:
        """
        Outscale Access Key
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        """
        Outscale Secret Key
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="extraTagsAlls")
    def extra_tags_alls(self) -> Optional[Sequence[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[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[str]:
        """
        Outscale VM type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        Outscale Region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="rootDiskIops")
    def root_disk_iops(self) -> Optional[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[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[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[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[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[str] = None,
                 cfgparams: Optional[Sequence[str]] = None,
                 clone_from: Optional[str] = None,
                 cloud_config: Optional[str] = None,
                 cloudinit: Optional[str] = None,
                 content_library: Optional[str] = None,
                 cpu_count: Optional[str] = None,
                 creation_type: Optional[str] = None,
                 custom_attributes: Optional[Sequence[str]] = None,
                 datacenter: Optional[str] = None,
                 datastore: Optional[str] = None,
                 datastore_cluster: Optional[str] = None,
                 disk_size: Optional[str] = None,
                 folder: Optional[str] = None,
                 graceful_shutdown_timeout: Optional[str] = None,
                 hostsystem: Optional[str] = None,
                 memory_size: Optional[str] = None,
                 networks: Optional[Sequence[str]] = None,
                 password: Optional[str] = None,
                 pool: Optional[str] = None,
                 ssh_password: Optional[str] = None,
                 ssh_port: Optional[str] = None,
                 ssh_user: Optional[str] = None,
                 ssh_user_group: Optional[str] = None,
                 tags: Optional[Sequence[str]] = None,
                 username: Optional[str] = None,
                 vapp_ip_allocation_policy: Optional[str] = None,
                 vapp_ip_protocol: Optional[str] = None,
                 vapp_properties: Optional[Sequence[str]] = None,
                 vapp_transport: Optional[str] = None,
                 vcenter: Optional[str] = None,
                 vcenter_port: Optional[str] = None):
        """
        :param str boot2docker_url: vSphere URL for boot2docker image
        :param Sequence[str] cfgparams: vSphere vm configuration parameters (used for guestinfo)
        :param str clone_from: If you choose creation type clone a name of what you want to clone is required
        :param str cloud_config: Filepath to a cloud-config yaml file to put into the ISO user-data
        :param str cloudinit: vSphere cloud-init filepath or url to add to guestinfo
        :param str content_library: If you choose to clone from a content library template specify the name of the library
        :param str cpu_count: vSphere CPU number for docker VM
        :param str creation_type: Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        :param Sequence[str] custom_attributes: vSphere custom attributes, format key/value e.g. '200=my custom value'
        :param str datacenter: vSphere datacenter for virtual machine
        :param str datastore: vSphere datastore for virtual machine
        :param str datastore_cluster: vSphere datastore cluster for virtual machine
        :param str disk_size: vSphere size of disk for docker VM (in MB)
        :param str folder: vSphere folder for the docker VM. This folder must already exist in the datacenter
        :param 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 str hostsystem: vSphere compute resource where the docker VM will be instantiated. This can be omitted if using a cluster with DRS
        :param str memory_size: vSphere size of memory for docker VM (in MB)
        :param Sequence[str] networks: vSphere network where the virtual machine will be attached
        :param str password: vSphere password
        :param str pool: vSphere resource pool for docker VM
        :param str ssh_password: If using a non-B2D image you can specify the ssh password
        :param str ssh_port: If using a non-B2D image you can specify the ssh port
        :param str ssh_user: If using a non-B2D image you can specify the ssh user
        :param 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[str] tags: vSphere tags id e.g. urn:xxx
        :param str username: vSphere username
        :param str vapp_ip_allocation_policy: vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        :param str vapp_ip_protocol: vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        :param Sequence[str] vapp_properties: vSphere vApp properties
        :param str vapp_transport: vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        :param str vcenter: vSphere IP/hostname for vCenter
        :param 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[str]:
        """
        vSphere URL for boot2docker image
        """
        return pulumi.get(self, "boot2docker_url")

    @property
    @pulumi.getter
    def cfgparams(self) -> Optional[Sequence[str]]:
        """
        vSphere vm configuration parameters (used for guestinfo)
        """
        return pulumi.get(self, "cfgparams")

    @property
    @pulumi.getter(name="cloneFrom")
    def clone_from(self) -> Optional[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[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[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[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[str]:
        """
        vSphere CPU number for docker VM
        """
        return pulumi.get(self, "cpu_count")

    @property
    @pulumi.getter(name="creationType")
    def creation_type(self) -> Optional[str]:
        """
        Creation type when creating a new virtual machine. Supported values: vm, template, library, legacy
        """
        return pulumi.get(self, "creation_type")

    @property
    @pulumi.getter(name="customAttributes")
    def custom_attributes(self) -> Optional[Sequence[str]]:
        """
        vSphere custom attributes, format key/value e.g. '200=my custom value'
        """
        return pulumi.get(self, "custom_attributes")

    @property
    @pulumi.getter
    def datacenter(self) -> Optional[str]:
        """
        vSphere datacenter for virtual machine
        """
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter
    def datastore(self) -> Optional[str]:
        """
        vSphere datastore for virtual machine
        """
        return pulumi.get(self, "datastore")

    @property
    @pulumi.getter(name="datastoreCluster")
    def datastore_cluster(self) -> Optional[str]:
        """
        vSphere datastore cluster for virtual machine
        """
        return pulumi.get(self, "datastore_cluster")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[str]:
        """
        vSphere size of disk for docker VM (in MB)
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        """
        vSphere folder for the docker VM. This folder must already exist in the datacenter
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[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[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[str]:
        """
        vSphere size of memory for docker VM (in MB)
        """
        return pulumi.get(self, "memory_size")

    @property
    @pulumi.getter
    def networks(self) -> Optional[Sequence[str]]:
        """
        vSphere network where the virtual machine will be attached
        """
        return pulumi.get(self, "networks")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        vSphere password
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def pool(self) -> Optional[str]:
        """
        vSphere resource pool for docker VM
        """
        return pulumi.get(self, "pool")

    @property
    @pulumi.getter(name="sshPassword")
    def ssh_password(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh password
        """
        return pulumi.get(self, "ssh_password")

    @property
    @pulumi.getter(name="sshPort")
    def ssh_port(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh port
        """
        return pulumi.get(self, "ssh_port")

    @property
    @pulumi.getter(name="sshUser")
    def ssh_user(self) -> Optional[str]:
        """
        If using a non-B2D image you can specify the ssh user
        """
        return pulumi.get(self, "ssh_user")

    @property
    @pulumi.getter(name="sshUserGroup")
    def ssh_user_group(self) -> Optional[str]:
        """
        If using a non-B2D image the uploaded keys will need chown'ed, defaults to staff e.g. docker:staff
        """
        return pulumi.get(self, "ssh_user_group")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        vSphere tags id e.g. urn:xxx
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        vSphere username
        """
        return pulumi.get(self, "username")

    @property
    @pulumi.getter(name="vappIpAllocationPolicy")
    def vapp_ip_allocation_policy(self) -> Optional[str]:
        """
        vSphere vApp IP allocation policy. Supported values are: dhcp, fixed, transient and fixedAllocated
        """
        return pulumi.get(self, "vapp_ip_allocation_policy")

    @property
    @pulumi.getter(name="vappIpProtocol")
    def vapp_ip_protocol(self) -> Optional[str]:
        """
        vSphere vApp IP protocol for this deployment. Supported values are: IPv4 and IPv6
        """
        return pulumi.get(self, "vapp_ip_protocol")

    @property
    @pulumi.getter(name="vappProperties")
    def vapp_properties(self) -> Optional[Sequence[str]]:
        """
        vSphere vApp properties
        """
        return pulumi.get(self, "vapp_properties")

    @property
    @pulumi.getter(name="vappTransport")
    def vapp_transport(self) -> Optional[str]:
        """
        vSphere OVF environment transports to use for properties. Supported values are: iso and com.vmware.guestInfo
        """
        return pulumi.get(self, "vapp_transport")

    @property
    @pulumi.getter
    def vcenter(self) -> Optional[str]:
        """
        vSphere IP/hostname for vCenter
        """
        return pulumi.get(self, "vcenter")

    @property
    @pulumi.getter(name="vcenterPort")
    def vcenter_port(self) -> Optional[str]:
        """
        vSphere Port for vCenter
        """
        return pulumi.get(self, "vcenter_port")


@pulumi.output_type
class NotifierDingtalkConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierDingtalkConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierDingtalkConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierDingtalkConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None,
                 secret: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: Dingtalk proxy URL
        :param str secret: Required for webhook with sign enabled
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Dingtalk proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter
    def secret(self) -> Optional[str]:
        """
        Required for webhook with sign enabled
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class NotifierMsteamsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierMsteamsConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierMsteamsConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierMsteamsConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: MS teams proxy URL
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        MS teams proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class NotifierPagerdutyConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceKey":
            suggest = "service_key"
        elif key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierPagerdutyConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierPagerdutyConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierPagerdutyConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 service_key: str,
                 proxy_url: Optional[str] = None):
        """
        :param str service_key: Pagerduty service key
        :param str proxy_url: Pagerduty proxy URL
        """
        pulumi.set(__self__, "service_key", service_key)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> str:
        """
        Pagerduty service key
        """
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Pagerduty proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class NotifierSlackConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierSlackConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierSlackConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierSlackConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_recipient: str,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str default_recipient: Slack default channel
        :param str url: Slack URL
        :param str proxy_url: Slack proxy URL
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Slack default channel
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Slack URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Slack proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class NotifierSmtpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierSmtpConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierSmtpConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierSmtpConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 default_recipient: str,
                 host: str,
                 port: int,
                 sender: str,
                 password: Optional[str] = None,
                 tls: Optional[bool] = None,
                 username: Optional[str] = None):
        """
        :param str default_recipient: SMTP default recipient (string)
        :param str host: SMTP host (string)
        :param int port: SMTP port (int)
        :param str sender: SMTP sender (string)
        :param str password: SMTP password (string)
        :param bool tls: SMTP tls. Default `true` (bool)
        :param str username: SMTP username (string)
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "sender", sender)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        SMTP default recipient (string)
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        SMTP host (string)
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        SMTP port (int)
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def sender(self) -> str:
        """
        SMTP sender (string)
        """
        return pulumi.get(self, "sender")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        SMTP password (string)
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def tls(self) -> Optional[bool]:
        """
        SMTP tls. Default `true` (bool)
        """
        return pulumi.get(self, "tls")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        SMTP username (string)
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class NotifierWebhookConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "proxyUrl":
            suggest = "proxy_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierWebhookConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierWebhookConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierWebhookConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook url (string)
        :param str proxy_url: Webhook proxy url (string)
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook url (string)
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Webhook proxy url (string)
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class NotifierWechatConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "proxyUrl":
            suggest = "proxy_url"
        elif key == "recipientType":
            suggest = "recipient_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in NotifierWechatConfig. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        NotifierWechatConfig.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        NotifierWechatConfig.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 agent: str,
                 corp: str,
                 default_recipient: str,
                 secret: str,
                 proxy_url: Optional[str] = None,
                 recipient_type: Optional[str] = None):
        """
        :param str agent: Wechat application agent ID
        :param str corp: Wechat corporation ID
        :param str default_recipient: Wechat default channel
        :param str secret: Wechat application secret
        :param str proxy_url: Wechat proxy URL
        :param str recipient_type: Wechat recipient type
        """
        pulumi.set(__self__, "agent", agent)
        pulumi.set(__self__, "corp", corp)
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "secret", secret)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if recipient_type is not None:
            pulumi.set(__self__, "recipient_type", recipient_type)

    @property
    @pulumi.getter
    def agent(self) -> str:
        """
        Wechat application agent ID
        """
        return pulumi.get(self, "agent")

    @property
    @pulumi.getter
    def corp(self) -> str:
        """
        Wechat corporation ID
        """
        return pulumi.get(self, "corp")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Wechat default channel
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Wechat application secret
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter(name="recipientType")
    def recipient_type(self) -> Optional[str]:
        """
        Wechat recipient type
        """
        return pulumi.get(self, "recipient_type")


@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[str] = None,
                 audit_version: Optional[str] = None,
                 enforce: Optional[str] = None,
                 enforce_version: Optional[str] = None,
                 warn: Optional[str] = None,
                 warn_version: Optional[str] = None):
        """
        :param str audit: Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param str audit_version: Pod Security Admission Configuration audit version (default: latest)
        :param str enforce: Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param str enforce_version: Pod Security Admission Configuration enforce version (default: latest)
        :param 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 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[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[str]:
        """
        Pod Security Admission Configuration audit version (default: latest)
        """
        return pulumi.get(self, "audit_version")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[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[str]:
        """
        Pod Security Admission Configuration enforce version (default: latest)
        """
        return pulumi.get(self, "enforce_version")

    @property
    @pulumi.getter
    def warn(self) -> Optional[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[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[str]] = None,
                 runtime_classes: Optional[Sequence[str]] = None,
                 usernames: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] namespaces: Pod Security Admission Configuration namespace exemptions
        :param Sequence[str] runtime_classes: Pod Security Admission Configuration runtime class exemptions
        :param Sequence[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[str]]:
        """
        Pod Security Admission Configuration namespace exemptions
        """
        return pulumi.get(self, "namespaces")

    @property
    @pulumi.getter(name="runtimeClasses")
    def runtime_classes(self) -> Optional[Sequence[str]]:
        """
        Pod Security Admission Configuration runtime class exemptions
        """
        return pulumi.get(self, "runtime_classes")

    @property
    @pulumi.getter
    def usernames(self) -> Optional[Sequence[str]]:
        """
        Pod Security Admission Configuration username exemptions
        """
        return pulumi.get(self, "usernames")


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedCsiDriver(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of the PodSecurityPolicyTemplate (string)
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the PodSecurityPolicyTemplate (string)
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedFlexVolume(dict):
    def __init__(__self__, *,
                 driver: str):
        """
        :param str driver: driver is the name of the Flexvolume driver.
        """
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        """
        driver is the name of the Flexvolume driver.
        """
        return pulumi.get(self, "driver")


@pulumi.output_type
class PodSecurityPolicyTemplateAllowedHostPath(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pathPrefix":
            suggest = "path_prefix"
        elif key == "readOnly":
            suggest = "read_only"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateAllowedHostPath. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateAllowedHostPath.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateAllowedHostPath.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 path_prefix: str,
                 read_only: Optional[bool] = None):
        """
        :param str path_prefix: pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        :param bool read_only: when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> str:
        """
        pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        """
        return pulumi.get(self, "path_prefix")

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[bool]:
        """
        when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        return pulumi.get(self, "read_only")


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateFsGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param Sequence['PodSecurityPolicyTemplateFsGroupRangeArgs'] ranges: ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.PodSecurityPolicyTemplateFsGroupRange']]:
        """
        ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        return pulumi.get(self, "rule")


@pulumi.output_type
class PodSecurityPolicyTemplateFsGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class PodSecurityPolicyTemplateHostPort(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroup(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsGroupRange']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        :param Sequence['PodSecurityPolicyTemplateRunAsGroupRangeArgs'] ranges: ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsGroupRange']]:
        """
        ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUser(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsUserRange']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        :param Sequence['PodSecurityPolicyTemplateRunAsUserRangeArgs'] ranges: ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.PodSecurityPolicyTemplateRunAsUserRange']]:
        """
        ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class PodSecurityPolicyTemplateRunAsUserRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class PodSecurityPolicyTemplateRuntimeClass(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "allowedRuntimeClassNames":
            suggest = "allowed_runtime_class_names"
        elif key == "defaultRuntimeClassName":
            suggest = "default_runtime_class_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateRuntimeClass. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateRuntimeClass.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateRuntimeClass.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 allowed_runtime_class_names: Sequence[str],
                 default_runtime_class_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_runtime_class_names: allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        :param str default_runtime_class_name: defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> Sequence[str]:
        """
        allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        """
        return pulumi.get(self, "allowed_runtime_class_names")

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[str]:
        """
        defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        return pulumi.get(self, "default_runtime_class_name")


@pulumi.output_type
class PodSecurityPolicyTemplateSeLinux(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "seLinuxOption":
            suggest = "se_linux_option"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PodSecurityPolicyTemplateSeLinux. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PodSecurityPolicyTemplateSeLinux.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PodSecurityPolicyTemplateSeLinux.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 rule: str,
                 se_linux_option: Optional['outputs.PodSecurityPolicyTemplateSeLinuxSeLinuxOption'] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable labels that may be set.
        :param 'PodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs' se_linux_option: seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable labels that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional['outputs.PodSecurityPolicyTemplateSeLinuxSeLinuxOption']:
        """
        seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        return pulumi.get(self, "se_linux_option")


@pulumi.output_type
class PodSecurityPolicyTemplateSeLinuxSeLinuxOption(dict):
    def __init__(__self__, *,
                 level: Optional[str] = None,
                 role: Optional[str] = None,
                 type: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param str level: Level is SELinux level label that applies to the container.
        :param str role: Role is a SELinux role label that applies to the container.
        :param str type: Type is a SELinux type label that applies to the container.
        :param str user: User is a SELinux user label that applies to the container.
        """
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def level(self) -> Optional[str]:
        """
        Level is SELinux level label that applies to the container.
        """
        return pulumi.get(self, "level")

    @property
    @pulumi.getter
    def role(self) -> Optional[str]:
        """
        Role is a SELinux role label that applies to the container.
        """
        return pulumi.get(self, "role")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type is a SELinux type label that applies to the container.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        """
        User is a SELinux user label that applies to the container.
        """
        return pulumi.get(self, "user")


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroup(dict):
    def __init__(__self__, *,
                 ranges: Optional[Sequence['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']] = None,
                 rule: Optional[str] = None):
        """
        :param Sequence['PodSecurityPolicyTemplateSupplementalGroupRangeArgs'] ranges: ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.PodSecurityPolicyTemplateSupplementalGroupRange']]:
        """
        ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        return pulumi.get(self, "rule")


@pulumi.output_type
class PodSecurityPolicyTemplateSupplementalGroupRange(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class ProjectAlertGroupRecipient(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "notifierId":
            suggest = "notifier_id"
        elif key == "defaultRecipient":
            suggest = "default_recipient"
        elif key == "notifierType":
            suggest = "notifier_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertGroupRecipient. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertGroupRecipient.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertGroupRecipient.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 notifier_id: str,
                 default_recipient: Optional[bool] = None,
                 notifier_type: Optional[str] = None,
                 recipient: Optional[str] = None):
        """
        :param str notifier_id: Recipient notifier ID
        :param bool default_recipient: Use notifier default recipient
        :param str notifier_type: Recipient notifier type
        :param str recipient: Recipient
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)
        if notifier_type is not None:
            pulumi.set(__self__, "notifier_type", notifier_type)
        if recipient is not None:
            pulumi.set(__self__, "recipient", recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> str:
        """
        Recipient notifier ID
        """
        return pulumi.get(self, "notifier_id")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[bool]:
        """
        Use notifier default recipient
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> Optional[str]:
        """
        Recipient notifier type
        """
        return pulumi.get(self, "notifier_type")

    @property
    @pulumi.getter
    def recipient(self) -> Optional[str]:
        """
        Recipient
        """
        return pulumi.get(self, "recipient")


@pulumi.output_type
class ProjectAlertRuleMetricRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "thresholdValue":
            suggest = "threshold_value"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRuleMetricRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRuleMetricRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRuleMetricRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: str,
                 expression: str,
                 threshold_value: float,
                 comparison: Optional[str] = None,
                 description: Optional[str] = None):
        """
        :param str duration: Metric rule duration
        :param str expression: Metric rule expression
        :param float threshold_value: Metric rule threshold value
        :param str comparison: Metric rule comparison
        :param str description: Metric rule description
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> str:
        """
        Metric rule duration
        """
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def expression(self) -> str:
        """
        Metric rule expression
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> float:
        """
        Metric rule threshold value
        """
        return pulumi.get(self, "threshold_value")

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        """
        Metric rule comparison
        """
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Metric rule description
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class ProjectAlertRulePodRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "podId":
            suggest = "pod_id"
        elif key == "restartIntervalSeconds":
            suggest = "restart_interval_seconds"
        elif key == "restartTimes":
            suggest = "restart_times"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRulePodRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRulePodRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRulePodRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 pod_id: str,
                 condition: Optional[str] = None,
                 restart_interval_seconds: Optional[int] = None,
                 restart_times: Optional[int] = None):
        """
        :param str pod_id: Pod ID
        :param str condition: Pod rule condition
        :param int restart_interval_seconds: Pod rule restart interval seconds
        :param int restart_times: Pod rule restart times
        """
        pulumi.set(__self__, "pod_id", pod_id)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if restart_interval_seconds is not None:
            pulumi.set(__self__, "restart_interval_seconds", restart_interval_seconds)
        if restart_times is not None:
            pulumi.set(__self__, "restart_times", restart_times)

    @property
    @pulumi.getter(name="podId")
    def pod_id(self) -> str:
        """
        Pod ID
        """
        return pulumi.get(self, "pod_id")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        Pod rule condition
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="restartIntervalSeconds")
    def restart_interval_seconds(self) -> Optional[int]:
        """
        Pod rule restart interval seconds
        """
        return pulumi.get(self, "restart_interval_seconds")

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[int]:
        """
        Pod rule restart times
        """
        return pulumi.get(self, "restart_times")


@pulumi.output_type
class ProjectAlertRuleWorkloadRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availablePercentage":
            suggest = "available_percentage"
        elif key == "workloadId":
            suggest = "workload_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectAlertRuleWorkloadRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectAlertRuleWorkloadRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectAlertRuleWorkloadRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 available_percentage: Optional[int] = None,
                 selector: Optional[Mapping[str, Any]] = None,
                 workload_id: Optional[str] = None):
        """
        :param int available_percentage: Workload rule available percentage
        :param Mapping[str, Any] selector: Workload rule selector
        :param str workload_id: Workload ID
        """
        if available_percentage is not None:
            pulumi.set(__self__, "available_percentage", available_percentage)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if workload_id is not None:
            pulumi.set(__self__, "workload_id", workload_id)

    @property
    @pulumi.getter(name="availablePercentage")
    def available_percentage(self) -> Optional[int]:
        """
        Workload rule available percentage
        """
        return pulumi.get(self, "available_percentage")

    @property
    @pulumi.getter
    def selector(self) -> Optional[Mapping[str, Any]]:
        """
        Workload rule selector
        """
        return pulumi.get(self, "selector")

    @property
    @pulumi.getter(name="workloadId")
    def workload_id(self) -> Optional[str]:
        """
        Workload ID
        """
        return pulumi.get(self, "workload_id")


@pulumi.output_type
class ProjectContainerResourceLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectContainerResourceLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectContainerResourceLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectContainerResourceLimit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class ProjectProjectMonitoringInput(dict):
    def __init__(__self__, *,
                 answers: Optional[Mapping[str, Any]] = None,
                 version: Optional[str] = None):
        """
        :param Mapping[str, Any] answers: Answers for monitor input
        :param str version: Monitoring version
        """
        if answers is not None:
            pulumi.set(__self__, "answers", answers)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def answers(self) -> Optional[Mapping[str, Any]]:
        """
        Answers for monitor input
        """
        return pulumi.get(self, "answers")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Monitoring version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class ProjectResourceQuota(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceDefaultLimit":
            suggest = "namespace_default_limit"
        elif key == "projectLimit":
            suggest = "project_limit"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuota. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuota.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuota.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 namespace_default_limit: 'outputs.ProjectResourceQuotaNamespaceDefaultLimit',
                 project_limit: 'outputs.ProjectResourceQuotaProjectLimit'):
        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':
        return pulumi.get(self, "namespace_default_limit")

    @property
    @pulumi.getter(name="projectLimit")
    def project_limit(self) -> 'outputs.ProjectResourceQuotaProjectLimit':
        return pulumi.get(self, "project_limit")


@pulumi.output_type
class ProjectResourceQuotaNamespaceDefaultLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuotaNamespaceDefaultLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuotaNamespaceDefaultLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuotaNamespaceDefaultLimit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class ProjectResourceQuotaProjectLimit(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "configMaps":
            suggest = "config_maps"
        elif key == "limitsCpu":
            suggest = "limits_cpu"
        elif key == "limitsMemory":
            suggest = "limits_memory"
        elif key == "persistentVolumeClaims":
            suggest = "persistent_volume_claims"
        elif key == "replicationControllers":
            suggest = "replication_controllers"
        elif key == "requestsCpu":
            suggest = "requests_cpu"
        elif key == "requestsMemory":
            suggest = "requests_memory"
        elif key == "requestsStorage":
            suggest = "requests_storage"
        elif key == "servicesLoadBalancers":
            suggest = "services_load_balancers"
        elif key == "servicesNodePorts":
            suggest = "services_node_ports"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ProjectResourceQuotaProjectLimit. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ProjectResourceQuotaProjectLimit.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ProjectResourceQuotaProjectLimit.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class RegistryRegistry(dict):
    def __init__(__self__, *,
                 address: str,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        pulumi.set(__self__, "address", address)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")


@pulumi.output_type
class RoleTemplateRule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiGroups":
            suggest = "api_groups"
        elif key == "nonResourceUrls":
            suggest = "non_resource_urls"
        elif key == "resourceNames":
            suggest = "resource_names"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in RoleTemplateRule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        RoleTemplateRule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        RoleTemplateRule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups
        :param Sequence[str] non_resource_urls: Policy rule non resource urls
        :param Sequence[str] resource_names: Policy rule resource names
        :param Sequence[str] resources: Policy rule resources
        :param Sequence[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[str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetClusterAksConfigResult(dict):
    def __init__(__self__, *,
                 agent_dns_prefix: str,
                 client_id: str,
                 client_secret: str,
                 kubernetes_version: str,
                 load_balancer_sku: str,
                 master_dns_prefix: str,
                 resource_group: str,
                 ssh_public_key_contents: str,
                 subnet: str,
                 subscription_id: str,
                 tag: Mapping[str, Any],
                 tags: Sequence[str],
                 tenant_id: str,
                 virtual_network: str,
                 virtual_network_resource_group: str,
                 aad_server_app_secret: Optional[str] = None,
                 aad_tenant_id: Optional[str] = None,
                 add_client_app_id: Optional[str] = None,
                 add_server_app_id: Optional[str] = None,
                 admin_username: Optional[str] = None,
                 agent_os_disk_size: Optional[int] = None,
                 agent_pool_name: Optional[str] = None,
                 agent_storage_profile: Optional[str] = None,
                 agent_vm_size: Optional[str] = None,
                 auth_base_url: Optional[str] = None,
                 base_url: Optional[str] = None,
                 count: Optional[int] = None,
                 dns_service_ip: Optional[str] = None,
                 docker_bridge_cidr: Optional[str] = None,
                 enable_http_application_routing: Optional[bool] = None,
                 enable_monitoring: Optional[bool] = None,
                 location: Optional[str] = None,
                 log_analytics_workspace: Optional[str] = None,
                 log_analytics_workspace_resource_group: Optional[str] = None,
                 max_pods: Optional[int] = None,
                 network_plugin: Optional[str] = None,
                 network_policy: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 service_cidr: Optional[str] = None):
        """
        :param str agent_dns_prefix: DNS prefix to be used to create the FQDN for the agent pool
        :param str client_id: Azure client ID to use
        :param str client_secret: Azure client secret associated with the "client id"
        :param str kubernetes_version: Specify the version of Kubernetes
        :param str load_balancer_sku: Load balancer type (basic | standard). Must be standard for auto-scaling
        :param str master_dns_prefix: DNS prefix to use the Kubernetes cluster control pane
        :param str resource_group: The name of the Cluster resource group
        :param str ssh_public_key_contents: Contents of the SSH public key used to authenticate with Linux hosts
        :param str subnet: The name of an existing Azure Virtual Subnet. Composite of agent virtual network subnet ID
        :param str subscription_id: Subscription credentials which uniquely identify Microsoft Azure subscription
        :param Mapping[str, Any] tag: Tags for Kubernetes cluster. For example, foo=bar
        :param Sequence[str] tags: Tags for Kubernetes cluster. For example, `["foo=bar","bar=foo"]`
        :param str tenant_id: Azure tenant ID to use
        :param str virtual_network: The name of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param str virtual_network_resource_group: The resource group of an existing Azure Virtual Network. Composite of agent virtual network subnet ID
        :param str aad_server_app_secret: The secret of an Azure Active Directory server application
        :param str aad_tenant_id: The ID of an Azure Active Directory tenant
        :param str add_client_app_id: The ID of an Azure Active Directory client application of type "Native". This application is for user login via kubectl
        :param str add_server_app_id: The ID of an Azure Active Directory server application of type "Web app/API". This application represents the managed cluster's apiserver (Server application)
        :param str admin_username: The administrator username to use for Linux hosts
        :param int agent_os_disk_size: GB size to be used to specify the disk for every machine in the agent pool. If you specify 0, it will apply the default according to the "agent vm size" specified
        :param str agent_pool_name: Name for the agent pool, upto 12 alphanumeric characters
        :param str agent_storage_profile: Storage profile specifies what kind of storage used on machine in the agent pool. Chooses from [ManagedDisks StorageAccount]
        :param str agent_vm_size: Size of machine in the agent pool
        :param str auth_base_url: Different authentication API url to use
        :param str base_url: Different resource management API url to use
        :param int count: Number of machines (VMs) in the agent pool. Allowed values must be in the range of 1 to 100 (inclusive)
        :param str dns_service_ip: An IP address assigned to the Kubernetes DNS service. It must be within the Kubernetes Service address range specified in "service cidr"
        :param str docker_bridge_cidr: A CIDR notation IP range assigned to the Docker bridge network. It must not overlap with any Subnet IP ranges or the Kubernetes Service address range specified in "service cidr"
        :param bool enable_http_application_routing: Enable the Kubernetes ingress with automatic public DNS name creation
        :param bool enable_monitoring: Turn on Azure Log Analytics monitoring. Uses the Log Analytics "Default" workspace if it exists, else creates one. if using an existing workspace, specifies "log analytics workspace resource id"
        :param str location: Azure Kubernetes cluster location
        :param str log_analytics_workspace: The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}'
        :param str log_analytics_workspace_resource_group: The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group
        :param int max_pods: Maximum number of pods that can run on a node
        :param str network_plugin: Network plugin used for building Kubernetes network. Chooses from [azure kubenet]
        :param str network_policy: Network policy used for building Kubernetes network. Chooses from [calico]
        :param str pod_cidr: A CIDR notation IP range from which to assign Kubernetes Pod IPs when "network plugin" is specified in "kubenet".
        :param str service_cidr: A CIDR notation IP range from which to assign Kubernetes Service cluster IPs. It must not overlap with any Subnet IP ranges
        """
        pulumi.set(__self__, "agent_dns_prefix", agent_dns_prefix)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        pulumi.set(__self__, "master_dns_prefix", master_dns_prefix)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "ssh_public_key_contents", ssh_public_key_contents)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "subscription_id", subscription_id)
        pulumi.set(__self__, "tag", tag)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if aad_server_app_secret is not None:
            pulumi.set(__self__, "aad_server_app_secret", aad_server_app_secret)
        if aad_tenant_id is not None:
            pulumi.set(__self__, "aad_tenant_id", aad_tenant_id)
        if add_client_app_id is not None:
            pulumi.set(__self__, "add_client_app_id", add_client_app_id)
        if add_server_app_id is not None:
            pulumi.set(__self__, "add_server_app_id", add_server_app_id)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if agent_os_disk_size is not None:
            pulumi.set(__self__, "agent_os_disk_size", agent_os_disk_size)
        if agent_pool_name is not None:
            pulumi.set(__self__, "agent_pool_name", agent_pool_name)
        if agent_storage_profile is not None:
            pulumi.set(__self__, "agent_storage_profile", agent_storage_profile)
        if agent_vm_size is not None:
            pulumi.set(__self__, "agent_vm_size", agent_vm_size)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if dns_service_ip is not None:
            pulumi.set(__self__, "dns_service_ip", dns_service_ip)
        if docker_bridge_cidr is not None:
            pulumi.set(__self__, "docker_bridge_cidr", docker_bridge_cidr)
        if enable_http_application_routing is not None:
            pulumi.set(__self__, "enable_http_application_routing", enable_http_application_routing)
        if enable_monitoring is not None:
            pulumi.set(__self__, "enable_monitoring", enable_monitoring)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if log_analytics_workspace is not None:
            pulumi.set(__self__, "log_analytics_workspace", log_analytics_workspace)
        if log_analytics_workspace_resource_group is not None:
            pulumi.set(__self__, "log_analytics_workspace_resource_group", log_analytics_workspace_resource_group)
        if max_pods is not None:
            pulumi.set(__self__, "max_pods", max_pods)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if network_policy is not None:
            pulumi.set(__self__, "network_policy", network_policy)
        if pod_cidr is not None:
            pulumi.set(__self__, "pod_cidr", pod_cidr)
        if service_cidr is not None:
            pulumi.set(__self__, "service_cidr", service_cidr)

    @property
    @pulumi.getter(name="agentDnsPrefix")
    def agent_dns_prefix(self) -> str:
        """
        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) -> str:
        """
        Azure client ID to use
        """
        return pulumi.get(self, "client_id")

    @property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> str:
        """
        Azure client secret associated with the "client id"
        """
        return pulumi.get(self, "client_secret")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        """
        Specify the version of Kubernetes
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> str:
        """
        Subscription credentials which uniquely identify Microsoft Azure subscription
        """
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter
    def tag(self) -> Mapping[str, Any]:
        """
        Tags for Kubernetes cluster. For example, foo=bar
        """
        warnings.warn("""Use tags argument instead as []string""", DeprecationWarning)
        pulumi.log.warn("""tag is deprecated: Use tags argument instead as []string""")

        return pulumi.get(self, "tag")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[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) -> str:
        """
        Azure tenant ID to use
        """
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> 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) -> 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[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[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[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[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[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[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[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[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[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[str]:
        """
        Different authentication API url to use
        """
        return pulumi.get(self, "auth_base_url")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        Different resource management API url to use
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter
    def count(self) -> Optional[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[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[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[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[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[str]:
        """
        Azure Kubernetes cluster location
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="logAnalyticsWorkspace")
    def log_analytics_workspace(self) -> Optional[str]:
        """
        The name of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses '{resource group}-{subscription id}-{location code}'
        """
        return pulumi.get(self, "log_analytics_workspace")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceResourceGroup")
    def log_analytics_workspace_resource_group(self) -> Optional[str]:
        """
        The resource group of an existing Azure Log Analytics Workspace to use for storing monitoring data. If not specified, uses the 'Cluster' resource group
        """
        return pulumi.get(self, "log_analytics_workspace_resource_group")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[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[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[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[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[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: str,
                 http_application_routing: bool,
                 linux_admin_username: str,
                 linux_ssh_public_key: str,
                 load_balancer_sku: str,
                 log_analytics_workspace_group: str,
                 log_analytics_workspace_name: str,
                 monitoring: bool,
                 name: str,
                 network_dns_service_ip: str,
                 network_docker_bridge_cidr: str,
                 network_pod_cidr: str,
                 network_policy: str,
                 network_service_cidr: str,
                 private_cluster: bool,
                 resource_group: str,
                 resource_location: str,
                 subnet: str,
                 tags: Mapping[str, Any],
                 virtual_network: str,
                 virtual_network_resource_group: str,
                 auth_base_url: Optional[str] = None,
                 authorized_ip_ranges: Optional[Sequence[str]] = None,
                 base_url: Optional[str] = None,
                 dns_prefix: Optional[str] = None,
                 imported: Optional[bool] = None,
                 kubernetes_version: Optional[str] = None,
                 network_plugin: Optional[str] = None,
                 node_pools: Optional[Sequence['outputs.GetClusterAksConfigV2NodePoolResult']] = None):
        """
        :param str cloud_credential_id: The AKS Cloud Credential ID to use
        :param bool http_application_routing: Enable AKS http application routing?
        :param str linux_admin_username: The AKS linux admin username
        :param str linux_ssh_public_key: The AKS linux ssh public key
        :param str load_balancer_sku: The AKS load balancer sku
        :param str log_analytics_workspace_group: The AKS log analytics workspace group
        :param str log_analytics_workspace_name: The AKS log analytics workspace name
        :param bool monitoring: Is AKS cluster monitoring enabled?
        :param str name: The name of the Cluster (string)
        :param str network_dns_service_ip: The AKS network dns service ip
        :param str network_docker_bridge_cidr: The AKS network docker bridge cidr
        :param str network_pod_cidr: The AKS network pod cidr
        :param str network_policy: The AKS network policy
        :param str network_service_cidr: The AKS network service cidr
        :param bool private_cluster: Is AKS cluster private?
        :param str resource_group: The AKS resource group
        :param str resource_location: The AKS resource location
        :param str subnet: The AKS subnet
        :param Mapping[str, Any] tags: The AKS cluster tags
        :param str virtual_network: The AKS virtual network
        :param str virtual_network_resource_group: The AKS virtual network resource group
        :param str auth_base_url: The AKS auth base url
        :param Sequence[str] authorized_ip_ranges: The AKS authorized ip ranges
        :param str base_url: The AKS base url
        :param str dns_prefix: The AKS dns prefix. Required if `import=false`
        :param bool imported: Is AKS cluster imported?
        :param str kubernetes_version: The kubernetes master version. Required if `import=false`
        :param 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`
        """
        pulumi.set(__self__, "cloud_credential_id", cloud_credential_id)
        pulumi.set(__self__, "http_application_routing", http_application_routing)
        pulumi.set(__self__, "linux_admin_username", linux_admin_username)
        pulumi.set(__self__, "linux_ssh_public_key", linux_ssh_public_key)
        pulumi.set(__self__, "load_balancer_sku", load_balancer_sku)
        pulumi.set(__self__, "log_analytics_workspace_group", log_analytics_workspace_group)
        pulumi.set(__self__, "log_analytics_workspace_name", log_analytics_workspace_name)
        pulumi.set(__self__, "monitoring", monitoring)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_dns_service_ip", network_dns_service_ip)
        pulumi.set(__self__, "network_docker_bridge_cidr", network_docker_bridge_cidr)
        pulumi.set(__self__, "network_pod_cidr", network_pod_cidr)
        pulumi.set(__self__, "network_policy", network_policy)
        pulumi.set(__self__, "network_service_cidr", network_service_cidr)
        pulumi.set(__self__, "private_cluster", private_cluster)
        pulumi.set(__self__, "resource_group", resource_group)
        pulumi.set(__self__, "resource_location", resource_location)
        pulumi.set(__self__, "subnet", subnet)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "virtual_network", virtual_network)
        pulumi.set(__self__, "virtual_network_resource_group", virtual_network_resource_group)
        if auth_base_url is not None:
            pulumi.set(__self__, "auth_base_url", auth_base_url)
        if authorized_ip_ranges is not None:
            pulumi.set(__self__, "authorized_ip_ranges", authorized_ip_ranges)
        if base_url is not None:
            pulumi.set(__self__, "base_url", base_url)
        if dns_prefix is not None:
            pulumi.set(__self__, "dns_prefix", dns_prefix)
        if imported is not None:
            pulumi.set(__self__, "imported", imported)
        if kubernetes_version is not None:
            pulumi.set(__self__, "kubernetes_version", kubernetes_version)
        if network_plugin is not None:
            pulumi.set(__self__, "network_plugin", network_plugin)
        if node_pools is not None:
            pulumi.set(__self__, "node_pools", node_pools)

    @property
    @pulumi.getter(name="cloudCredentialId")
    def cloud_credential_id(self) -> str:
        """
        The AKS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

    @property
    @pulumi.getter(name="httpApplicationRouting")
    def http_application_routing(self) -> bool:
        """
        Enable AKS http application routing?
        """
        return pulumi.get(self, "http_application_routing")

    @property
    @pulumi.getter(name="linuxAdminUsername")
    def linux_admin_username(self) -> str:
        """
        The AKS linux admin username
        """
        return pulumi.get(self, "linux_admin_username")

    @property
    @pulumi.getter(name="linuxSshPublicKey")
    def linux_ssh_public_key(self) -> 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) -> str:
        """
        The AKS load balancer sku
        """
        return pulumi.get(self, "load_balancer_sku")

    @property
    @pulumi.getter(name="logAnalyticsWorkspaceGroup")
    def log_analytics_workspace_group(self) -> 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) -> str:
        """
        The AKS log analytics workspace name
        """
        return pulumi.get(self, "log_analytics_workspace_name")

    @property
    @pulumi.getter
    def monitoring(self) -> bool:
        """
        Is AKS cluster monitoring enabled?
        """
        return pulumi.get(self, "monitoring")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="networkDnsServiceIp")
    def network_dns_service_ip(self) -> str:
        """
        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) -> 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) -> str:
        """
        The AKS network pod cidr
        """
        return pulumi.get(self, "network_pod_cidr")

    @property
    @pulumi.getter(name="networkPolicy")
    def network_policy(self) -> str:
        """
        The AKS network policy
        """
        return pulumi.get(self, "network_policy")

    @property
    @pulumi.getter(name="networkServiceCidr")
    def network_service_cidr(self) -> str:
        """
        The AKS network service cidr
        """
        return pulumi.get(self, "network_service_cidr")

    @property
    @pulumi.getter(name="privateCluster")
    def private_cluster(self) -> bool:
        """
        Is AKS cluster private?
        """
        return pulumi.get(self, "private_cluster")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        """
        The AKS resource group
        """
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="resourceLocation")
    def resource_location(self) -> str:
        """
        The AKS resource location
        """
        return pulumi.get(self, "resource_location")

    @property
    @pulumi.getter
    def subnet(self) -> str:
        """
        The AKS subnet
        """
        return pulumi.get(self, "subnet")

    @property
    @pulumi.getter
    def tags(self) -> Mapping[str, Any]:
        """
        The AKS cluster tags
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="virtualNetwork")
    def virtual_network(self) -> str:
        """
        The AKS virtual network
        """
        return pulumi.get(self, "virtual_network")

    @property
    @pulumi.getter(name="virtualNetworkResourceGroup")
    def virtual_network_resource_group(self) -> 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[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[str]]:
        """
        The AKS authorized ip ranges
        """
        return pulumi.get(self, "authorized_ip_ranges")

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> Optional[str]:
        """
        The AKS base url
        """
        return pulumi.get(self, "base_url")

    @property
    @pulumi.getter(name="dnsPrefix")
    def dns_prefix(self) -> Optional[str]:
        """
        The AKS dns prefix. Required if `import=false`
        """
        return pulumi.get(self, "dns_prefix")

    @property
    @pulumi.getter
    def imported(self) -> Optional[bool]:
        """
        Is AKS cluster imported?
        """
        return pulumi.get(self, "imported")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> Optional[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[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")


@pulumi.output_type
class GetClusterAksConfigV2NodePoolResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, Any],
                 name: str,
                 taints: Sequence[str],
                 vm_size: str,
                 availability_zones: Optional[Sequence[str]] = None,
                 count: Optional[int] = None,
                 enable_auto_scaling: Optional[bool] = None,
                 max_count: Optional[int] = None,
                 max_pods: Optional[int] = None,
                 max_surge: Optional[str] = None,
                 min_count: Optional[int] = None,
                 mode: Optional[str] = None,
                 orchestrator_version: Optional[str] = None,
                 os_disk_size_gb: Optional[int] = None,
                 os_disk_type: Optional[str] = None,
                 os_type: Optional[str] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param str name: The name of the Cluster (string)
        :param Sequence[str] taints: The AKS node pool taints
        :param str vm_size: The AKS node pool vm size
        :param Sequence[str] availability_zones: The AKS node pool availability zones
        :param int count: The AKS node pool count
        :param bool enable_auto_scaling: Is AKS node pool auto scaling enabled?
        :param int max_count: The AKS node pool max count
        :param int max_pods: The AKS node pool max pods
        :param str max_surge: The AKS node pool max surge
        :param int min_count: The AKS node pool min count
        :param str mode: The AKS node pool mode
        :param str orchestrator_version: The AKS node pool orchestrator version
        :param int os_disk_size_gb: The AKS node pool os disk size gb
        :param str os_disk_type: The AKS node pool os disk type
        :param 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, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def taints(self) -> Sequence[str]:
        """
        The AKS node pool taints
        """
        return pulumi.get(self, "taints")

    @property
    @pulumi.getter(name="vmSize")
    def vm_size(self) -> str:
        """
        The AKS node pool vm size
        """
        return pulumi.get(self, "vm_size")

    @property
    @pulumi.getter(name="availabilityZones")
    def availability_zones(self) -> Optional[Sequence[str]]:
        """
        The AKS node pool availability zones
        """
        return pulumi.get(self, "availability_zones")

    @property
    @pulumi.getter
    def count(self) -> Optional[int]:
        """
        The AKS node pool count
        """
        return pulumi.get(self, "count")

    @property
    @pulumi.getter(name="enableAutoScaling")
    def enable_auto_scaling(self) -> Optional[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[int]:
        """
        The AKS node pool max count
        """
        return pulumi.get(self, "max_count")

    @property
    @pulumi.getter(name="maxPods")
    def max_pods(self) -> Optional[int]:
        """
        The AKS node pool max pods
        """
        return pulumi.get(self, "max_pods")

    @property
    @pulumi.getter(name="maxSurge")
    def max_surge(self) -> Optional[str]:
        """
        The AKS node pool max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="minCount")
    def min_count(self) -> Optional[int]:
        """
        The AKS node pool min count
        """
        return pulumi.get(self, "min_count")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        """
        The AKS node pool mode
        """
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="orchestratorVersion")
    def orchestrator_version(self) -> Optional[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[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[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[str]:
        """
        Enable AKS node pool os type
        """
        return pulumi.get(self, "os_type")


@pulumi.output_type
class GetClusterAlertGroupRecipientResult(dict):
    def __init__(__self__, *,
                 notifier_id: str,
                 notifier_type: str,
                 recipient: str,
                 default_recipient: Optional[bool] = None):
        """
        :param str notifier_id: Recipient notifier ID
        :param str notifier_type: Recipient notifier type
        :param str recipient: Recipient
        :param bool default_recipient: Use notifier default recipient
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        pulumi.set(__self__, "notifier_type", notifier_type)
        pulumi.set(__self__, "recipient", recipient)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> str:
        """
        Recipient notifier ID
        """
        return pulumi.get(self, "notifier_id")

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> str:
        """
        Recipient notifier type
        """
        return pulumi.get(self, "notifier_type")

    @property
    @pulumi.getter
    def recipient(self) -> str:
        """
        Recipient
        """
        return pulumi.get(self, "recipient")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[bool]:
        """
        Use notifier default recipient
        """
        return pulumi.get(self, "default_recipient")


@pulumi.output_type
class GetClusterAlertRuleEventRuleResult(dict):
    def __init__(__self__, *,
                 resource_kind: str,
                 event_type: Optional[str] = None):
        """
        :param str resource_kind: Resource kind
        :param str event_type: Event type
        """
        pulumi.set(__self__, "resource_kind", resource_kind)
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)

    @property
    @pulumi.getter(name="resourceKind")
    def resource_kind(self) -> str:
        """
        Resource kind
        """
        return pulumi.get(self, "resource_kind")

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional[str]:
        """
        Event type
        """
        return pulumi.get(self, "event_type")


@pulumi.output_type
class GetClusterAlertRuleMetricRuleResult(dict):
    def __init__(__self__, *,
                 duration: str,
                 expression: str,
                 threshold_value: float,
                 comparison: Optional[str] = None,
                 description: Optional[str] = None):
        """
        :param str duration: Metric rule duration
        :param str expression: Metric rule expression
        :param float threshold_value: Metric rule threshold value
        :param str comparison: Metric rule comparison
        :param str description: Metric rule description
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> str:
        """
        Metric rule duration
        """
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def expression(self) -> str:
        """
        Metric rule expression
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> float:
        """
        Metric rule threshold value
        """
        return pulumi.get(self, "threshold_value")

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        """
        Metric rule comparison
        """
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Metric rule description
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class GetClusterAlertRuleNodeRuleResult(dict):
    def __init__(__self__, *,
                 condition: Optional[str] = None,
                 cpu_threshold: Optional[int] = None,
                 mem_threshold: Optional[int] = None,
                 node_id: Optional[str] = None,
                 selector: Optional[Mapping[str, Any]] = None):
        """
        :param str condition: Node rule condition
        :param int cpu_threshold: Node rule cpu threshold
        :param int mem_threshold: Node rule mem threshold
        :param str node_id: Node ID
        :param Mapping[str, Any] selector: Node rule selector
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if cpu_threshold is not None:
            pulumi.set(__self__, "cpu_threshold", cpu_threshold)
        if mem_threshold is not None:
            pulumi.set(__self__, "mem_threshold", mem_threshold)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        Node rule condition
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="cpuThreshold")
    def cpu_threshold(self) -> Optional[int]:
        """
        Node rule cpu threshold
        """
        return pulumi.get(self, "cpu_threshold")

    @property
    @pulumi.getter(name="memThreshold")
    def mem_threshold(self) -> Optional[int]:
        """
        Node rule mem threshold
        """
        return pulumi.get(self, "mem_threshold")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        """
        Node ID
        """
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def selector(self) -> Optional[Mapping[str, Any]]:
        """
        Node rule selector
        """
        return pulumi.get(self, "selector")


@pulumi.output_type
class GetClusterAlertRuleSystemServiceRuleResult(dict):
    def __init__(__self__, *,
                 condition: Optional[str] = None):
        """
        :param str condition: System service rule condition
        """
        if condition is not None:
            pulumi.set(__self__, "condition", condition)

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        System service rule condition
        """
        return pulumi.get(self, "condition")


@pulumi.output_type
class GetClusterClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterClusterMonitoringInputResult(dict):
    def __init__(__self__, *,
                 answers: Optional[Mapping[str, Any]] = None,
                 version: Optional[str] = None):
        """
        :param Mapping[str, Any] answers: Answers for monitor input
        :param str version: Monitoring version
        """
        if answers is not None:
            pulumi.set(__self__, "answers", answers)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def answers(self) -> Optional[Mapping[str, Any]]:
        """
        Answers for monitor input
        """
        return pulumi.get(self, "answers")

    @property
    @pulumi.getter
    def version(self) -> Optional[str]:
        """
        Monitoring version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_id: str,
                 command: str,
                 id: str,
                 insecure_command: str,
                 insecure_node_command: str,
                 insecure_windows_node_command: str,
                 labels: Mapping[str, Any],
                 manifest_url: str,
                 name: str,
                 node_command: str,
                 token: str,
                 windows_node_command: str):
        """
        :param Mapping[str, Any] annotations: (Computed) Annotations for Node Pool object (map)
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "insecure_command", insecure_command)
        pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "manifest_url", manifest_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_command", node_command)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Mapping[str, Any]:
        """
        (Computed) Annotations for Node Pool object (map)
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> str:
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> str:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> str:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> str:
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> str:
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> str:
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> str:
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class GetClusterClusterTemplateAnswersResult(dict):
    def __init__(__self__, *,
                 cluster_id: str,
                 project_id: str,
                 values: Mapping[str, Any]):
        """
        :param str cluster_id: Cluster ID for answer
        :param str project_id: Project ID for answer
        :param Mapping[str, Any] 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) -> str:
        """
        Cluster ID for answer
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        Project ID for answer
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def values(self) -> Mapping[str, Any]:
        """
        Key/values for answer
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetClusterClusterTemplateQuestionResult(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        """
        :param str default: Default variable value
        :param str variable: Variable name
        :param bool required: Required variable
        :param 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) -> str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClusterEksConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 kubernetes_version: str,
                 secret_key: str,
                 user_data: str,
                 ami: Optional[str] = None,
                 associate_worker_node_public_ip: Optional[bool] = None,
                 desired_nodes: Optional[int] = None,
                 ebs_encryption: Optional[bool] = None,
                 instance_type: Optional[str] = None,
                 key_pair_name: Optional[str] = None,
                 maximum_nodes: Optional[int] = None,
                 minimum_nodes: Optional[int] = None,
                 node_volume_size: Optional[int] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 session_token: Optional[str] = None,
                 subnets: Optional[Sequence[str]] = None,
                 virtual_network: Optional[str] = None):
        """
        :param str access_key: The AWS Client ID to use
        :param str kubernetes_version: The kubernetes master version
        :param str secret_key: The AWS Client Secret associated with the Client ID
        :param str user_data: Pass user-data to the nodes to perform automated configuration tasks
        :param str ami: A custom AMI ID to use for the worker nodes instead of the default
        :param bool associate_worker_node_public_ip: Associate public ip EKS worker nodes
        :param int desired_nodes: The desired number of worker nodes
        :param bool ebs_encryption: Enables EBS encryption of worker nodes
        :param str instance_type: The type of machine to use for worker nodes
        :param str key_pair_name: Allow user to specify key name to use
        :param int maximum_nodes: The maximum number of worker nodes
        :param int minimum_nodes: The minimum number of worker nodes
        :param int node_volume_size: The volume size for each node
        :param str region: The AWS Region to create the EKS cluster in
        :param Sequence[str] security_groups: List of security groups to use for the cluster
        :param str service_role: The service role to use to perform the cluster operations in AWS
        :param str session_token: A session token to use with the client key and secret if applicable
        :param Sequence[str] subnets: List of subnets in the virtual network to use
        :param 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) -> str:
        """
        The AWS Client ID to use
        """
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        """
        The AWS Client Secret associated with the Client ID
        """
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> 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[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[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[int]:
        """
        The desired number of worker nodes
        """
        return pulumi.get(self, "desired_nodes")

    @property
    @pulumi.getter(name="ebsEncryption")
    def ebs_encryption(self) -> Optional[bool]:
        """
        Enables EBS encryption of worker nodes
        """
        return pulumi.get(self, "ebs_encryption")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[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[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[int]:
        """
        The maximum number of worker nodes
        """
        return pulumi.get(self, "maximum_nodes")

    @property
    @pulumi.getter(name="minimumNodes")
    def minimum_nodes(self) -> Optional[int]:
        """
        The minimum number of worker nodes
        """
        return pulumi.get(self, "minimum_nodes")

    @property
    @pulumi.getter(name="nodeVolumeSize")
    def node_volume_size(self) -> Optional[int]:
        """
        The volume size for each node
        """
        return pulumi.get(self, "node_volume_size")

    @property
    @pulumi.getter
    def region(self) -> Optional[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[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[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[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[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[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: str,
                 kubernetes_version: str,
                 name: str,
                 node_groups: Sequence['outputs.GetClusterEksConfigV2NodeGroupResult'],
                 private_access: bool,
                 public_access: bool,
                 public_access_sources: Sequence[str],
                 secrets_encryption: bool,
                 imported: Optional[bool] = None,
                 kms_key: Optional[str] = None,
                 logging_types: Optional[Sequence[str]] = None,
                 region: Optional[str] = None,
                 security_groups: Optional[Sequence[str]] = None,
                 service_role: Optional[str] = None,
                 subnets: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str cloud_credential_id: The AWS Cloud Credential ID to use
        :param str kubernetes_version: The kubernetes master version
        :param str name: The name of the Cluster (string)
        :param Sequence['GetClusterEksConfigV2NodeGroupArgs'] node_groups: The AWS node groups to use
        :param bool private_access: The EKS cluster has private access
        :param bool public_access: The EKS cluster has public access
        :param Sequence[str] public_access_sources: The EKS cluster public access sources
        :param bool secrets_encryption: Enable EKS cluster secret encryption
        :param bool imported: Is EKS cluster imported?
        :param str kms_key: The AWS kms key to use
        :param Sequence[str] logging_types: The AWS logging types
        :param str region: The AWS Region to create the EKS cluster in
        :param Sequence[str] security_groups: List of security groups to use for the cluster
        :param str service_role: The AWS service role to use
        :param Sequence[str] subnets: List of subnets in the virtual network to use
        :param Mapping[str, Any] 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) -> str:
        """
        The AWS Cloud Credential ID to use
        """
        return pulumi.get(self, "cloud_credential_id")

    @property
    @pulumi.getter(name="kubernetesVersion")
    def kubernetes_version(self) -> str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeGroups")
    def node_groups(self) -> Sequence['outputs.GetClusterEksConfigV2NodeGroupResult']:
        """
        The AWS node groups to use
        """
        return pulumi.get(self, "node_groups")

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> bool:
        """
        The EKS cluster has private access
        """
        return pulumi.get(self, "private_access")

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> bool:
        """
        The EKS cluster has public access
        """
        return pulumi.get(self, "public_access")

    @property
    @pulumi.getter(name="publicAccessSources")
    def public_access_sources(self) -> Sequence[str]:
        """
        The EKS cluster public access sources
        """
        return pulumi.get(self, "public_access_sources")

    @property
    @pulumi.getter(name="secretsEncryption")
    def secrets_encryption(self) -> bool:
        """
        Enable EKS cluster secret encryption
        """
        return pulumi.get(self, "secrets_encryption")

    @property
    @pulumi.getter
    def imported(self) -> Optional[bool]:
        """
        Is EKS cluster imported?
        """
        return pulumi.get(self, "imported")

    @property
    @pulumi.getter(name="kmsKey")
    def kms_key(self) -> Optional[str]:
        """
        The AWS kms key to use
        """
        return pulumi.get(self, "kms_key")

    @property
    @pulumi.getter(name="loggingTypes")
    def logging_types(self) -> Optional[Sequence[str]]:
        """
        The AWS logging types
        """
        return pulumi.get(self, "logging_types")

    @property
    @pulumi.getter
    def region(self) -> Optional[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[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[str]:
        """
        The AWS service role to use
        """
        return pulumi.get(self, "service_role")

    @property
    @pulumi.getter
    def subnets(self) -> Optional[Sequence[str]]:
        """
        List of subnets in the virtual network to use
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        The EKS cluster tags
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupResult(dict):
    def __init__(__self__, *,
                 name: str,
                 subnets: Sequence[str],
                 user_data: str,
                 version: str,
                 desired_size: Optional[int] = None,
                 disk_size: Optional[int] = None,
                 ec2_ssh_key: Optional[str] = None,
                 gpu: Optional[bool] = None,
                 image_id: Optional[str] = None,
                 instance_type: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 launch_templates: Optional[Sequence['outputs.GetClusterEksConfigV2NodeGroupLaunchTemplateResult']] = None,
                 max_size: Optional[int] = None,
                 min_size: Optional[int] = None,
                 node_role: Optional[str] = None,
                 request_spot_instances: Optional[bool] = None,
                 resource_tags: Optional[Mapping[str, Any]] = None,
                 spot_instance_types: Optional[Sequence[str]] = None,
                 tags: Optional[Mapping[str, Any]] = None):
        """
        :param str name: The name of the Cluster (string)
        :param Sequence[str] subnets: The EKS node group subnets
        :param str user_data: The EKS node group user data
        :param str version: The EKS node group k8s version
        :param int desired_size: The EKS node group desired size
        :param int disk_size: The EKS node group disk size
        :param str ec2_ssh_key: The EKS node group ssh key
        :param bool gpu: Is EKS cluster using gpu?
        :param str image_id: The EKS node group image ID
        :param str instance_type: The EKS node group instance type
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence['GetClusterEksConfigV2NodeGroupLaunchTemplateArgs'] launch_templates: The EKS node groups launch template
        :param int max_size: The EKS node group maximum size
        :param int min_size: The EKS node group minimum size
        :param str node_role: The EKS node group node role ARN
        :param bool request_spot_instances: Enable EKS node group request spot instances
        :param Mapping[str, Any] resource_tags: The EKS node group resource tags
        :param Sequence[str] spot_instance_types: The EKS node group spot instance types
        :param Mapping[str, Any] 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) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def subnets(self) -> Sequence[str]:
        """
        The EKS node group subnets
        """
        return pulumi.get(self, "subnets")

    @property
    @pulumi.getter(name="userData")
    def user_data(self) -> str:
        """
        The EKS node group user data
        """
        return pulumi.get(self, "user_data")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The EKS node group k8s version
        """
        return pulumi.get(self, "version")

    @property
    @pulumi.getter(name="desiredSize")
    def desired_size(self) -> Optional[int]:
        """
        The EKS node group desired size
        """
        return pulumi.get(self, "desired_size")

    @property
    @pulumi.getter(name="diskSize")
    def disk_size(self) -> Optional[int]:
        """
        The EKS node group disk size
        """
        return pulumi.get(self, "disk_size")

    @property
    @pulumi.getter(name="ec2SshKey")
    def ec2_ssh_key(self) -> Optional[str]:
        """
        The EKS node group ssh key
        """
        return pulumi.get(self, "ec2_ssh_key")

    @property
    @pulumi.getter
    def gpu(self) -> Optional[bool]:
        """
        Is EKS cluster using gpu?
        """
        return pulumi.get(self, "gpu")

    @property
    @pulumi.getter(name="imageId")
    def image_id(self) -> Optional[str]:
        """
        The EKS node group image ID
        """
        return pulumi.get(self, "image_id")

    @property
    @pulumi.getter(name="instanceType")
    def instance_type(self) -> Optional[str]:
        """
        The EKS node group instance type
        """
        return pulumi.get(self, "instance_type")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="launchTemplates")
    def launch_templates(self) -> Optional[Sequence['outputs.GetClusterEksConfigV2NodeGroupLaunchTemplateResult']]:
        """
        The EKS node groups launch template
        """
        return pulumi.get(self, "launch_templates")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        """
        The EKS node group maximum size
        """
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter(name="minSize")
    def min_size(self) -> Optional[int]:
        """
        The EKS node group minimum size
        """
        return pulumi.get(self, "min_size")

    @property
    @pulumi.getter(name="nodeRole")
    def node_role(self) -> Optional[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[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, Any]]:
        """
        The EKS node group resource tags
        """
        return pulumi.get(self, "resource_tags")

    @property
    @pulumi.getter(name="spotInstanceTypes")
    def spot_instance_types(self) -> Optional[Sequence[str]]:
        """
        The EKS node group spot instance types
        """
        return pulumi.get(self, "spot_instance_types")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Mapping[str, Any]]:
        """
        The EKS node group tags
        """
        return pulumi.get(self, "tags")


@pulumi.output_type
class GetClusterEksConfigV2NodeGroupLaunchTemplateResult(dict):
    def __init__(__self__, *,
                 id: str,
                 name: str,
                 version: Optional[int] = None):
        """
        :param str id: (Computed) The ID of the resource (string)
        :param str name: The name of the Cluster (string)
        :param 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) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> Optional[int]:
        """
        The EKS node group launch template version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterGkeConfigResult(dict):
    def __init__(__self__, *,
                 cluster_ipv4_cidr: str,
                 credential: str,
                 disk_type: str,
                 image_type: str,
                 ip_policy_cluster_ipv4_cidr_block: str,
                 ip_policy_cluster_secondary_range_name: str,
                 ip_policy_node_ipv4_cidr_block: str,
                 ip_policy_services_ipv4_cidr_block: str,
                 ip_policy_services_secondary_range_name: str,
                 ip_policy_subnetwork_name: str,
                 labels: Mapping[str, Any],
                 locations: Sequence[str],
                 machine_type: str,
                 maintenance_window: str,
                 master_ipv4_cidr_block: str,
                 master_version: str,
                 network: str,
                 node_pool: str,
                 node_version: str,
                 oauth_scopes: Sequence[str],
                 project_id: str,
                 resource_labels: Mapping[str, Any],
                 service_account: str,
                 sub_network: str,
                 description: Optional[str] = None,
                 disk_size_gb: Optional[int] = None,
                 enable_alpha_feature: Optional[bool] = None,
                 enable_auto_repair: Optional[bool] = None,
                 enable_auto_upgrade: Optional[bool] = None,
                 enable_horizontal_pod_autoscaling: Optional[bool] = None,
                 enable_http_load_balancing: Optional[bool] = None,
                 enable_kubernetes_dashboard: Optional[bool] = None,
                 enable_legacy_abac: Optional[bool] = None,
                 enable_master_authorized_network: Optional[bool] = None,
                 enable_network_policy_config: Optional[bool] = None,
                 enable_nodepool_autoscaling: Optional[bool] = None,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None,
                 enable_stackdriver_logging: Optional[bool] = None,
                 enable_stackdriver_monitoring: Optional[bool] = None,
                 ip_policy_create_subnetwork: Optional[bool] = None,
                 issue_client_certificate: Optional[bool] = None,
                 kubernetes_dashboard: Optional[bool] = None,
                 local_ssd_count: Optional[int] = None,
                 master_authorized_network_cidr_blocks: Optional[Sequence[str]] = None,
                 max_node_count: Optional[int] = None,
                 min_node_count: Optional[int] = None,
                 node_count: Optional[int] = None,
                 preemptible: Optional[bool] = None,
                 region: Optional[str] = None,
                 taints: Optional[Sequence[str]] = None,
                 use_ip_aliases: Optional[bool] = None,
                 zone: Optional[str] = None):
        """
        :param str cluster_ipv4_cidr: The IP address range of the container pods
        :param str credential: The contents of the GC credential file
        :param str disk_type: Type of the disk attached to each node
        :param str image_type: The image to use for the worker nodes
        :param str ip_policy_cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs
        :param str ip_policy_cluster_secondary_range_name: The name of the secondary range to be used for the cluster CIDR block
        :param str ip_policy_node_ipv4_cidr_block: The IP address range of the instance IPs in this cluster
        :param str ip_policy_services_ipv4_cidr_block: The IP address range of the services IPs in this cluster
        :param str ip_policy_services_secondary_range_name: The name of the secondary range to be used for the services CIDR block
        :param str ip_policy_subnetwork_name: A custom subnetwork name to be used if createSubnetwork is true
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[str] locations: Locations to use for the cluster
        :param str machine_type: The machine type to use for the worker nodes
        :param str maintenance_window: When to performance updates on the nodes, in 24-hour time
        :param str master_ipv4_cidr_block: The IP range in CIDR notation to use for the hosted master network
        :param str master_version: The kubernetes master version
        :param str network: The network to use for the cluster
        :param str node_pool: The ID of the cluster node pool
        :param str node_version: The version of kubernetes to use on the nodes
        :param Sequence[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 str project_id: The ID of your project to use when creating a cluster
        :param Mapping[str, Any] resource_labels: The map of Kubernetes labels (key/value pairs) to be applied to each cluster
        :param str service_account: The Google Cloud Platform Service Account to be used by the node VMs
        :param str sub_network: The sub-network to use for the cluster
        :param str description: (Computed) The description for Cluster (string)
        :param int disk_size_gb: Size of the disk attached to each node
        :param bool enable_alpha_feature: To enable kubernetes alpha feature
        :param bool enable_auto_repair: Specifies whether the node auto-repair is enabled for the node pool
        :param bool enable_auto_upgrade: Specifies whether node auto-upgrade is enabled for the node pool
        :param bool enable_horizontal_pod_autoscaling: Enable horizontal pod autoscaling for the cluster
        :param bool enable_http_load_balancing: Enable http load balancing for the cluster
        :param bool enable_kubernetes_dashboard: Whether to enable the kubernetes dashboard
        :param bool enable_legacy_abac: Whether to enable legacy abac on the cluster
        :param bool enable_master_authorized_network: Whether or not master authorized network is enabled
        :param bool enable_network_policy_config: Enable network policy config for the cluster
        :param bool enable_nodepool_autoscaling: Enable nodepool autoscaling
        :param bool enable_private_endpoint: Whether the master's internal IP address is used as the cluster endpoint
        :param bool enable_private_nodes: Whether nodes have internal IP address only
        :param bool enable_stackdriver_logging: Enable stackdriver logging
        :param bool enable_stackdriver_monitoring: Enable stackdriver monitoring
        :param bool ip_policy_create_subnetwork: Whether a new subnetwork will be created automatically for the cluster
        :param bool issue_client_certificate: Issue a client certificate
        :param bool kubernetes_dashboard: Enable the kubernetes dashboard
        :param int local_ssd_count: The number of local SSD disks to be attached to the node
        :param Sequence[str] master_authorized_network_cidr_blocks: Define up to 10 external networks that could access Kubernetes master through HTTPS
        :param 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 int min_node_count: Minimmum number of nodes in the NodePool. Must be >= 1 and <= maxNodeCount
        :param int node_count: The number of nodes to create in this cluster
        :param bool preemptible: Whether the nodes are created as preemptible VM instances
        :param str region: The region to launch the cluster. Region or zone should be used
        :param Sequence[str] taints: List of kubernetes taints to be applied to each node
        :param bool use_ip_aliases: Whether alias IPs will be used for pod IPs in the cluster
        :param 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) -> str:
        """
        The IP address range of the container pods
        """
        return pulumi.get(self, "cluster_ipv4_cidr")

    @property
    @pulumi.getter
    def credential(self) -> str:
        """
        The contents of the GC credential file
        """
        return pulumi.get(self, "credential")

    @property
    @pulumi.getter(name="diskType")
    def disk_type(self) -> str:
        """
        Type of the disk attached to each node
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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) -> 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, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def locations(self) -> Sequence[str]:
        """
        Locations to use for the cluster
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> 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) -> 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) -> 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) -> str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "master_version")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The network to use for the cluster
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="nodePool")
    def node_pool(self) -> str:
        """
        The ID of the cluster node pool
        """
        return pulumi.get(self, "node_pool")

    @property
    @pulumi.getter(name="nodeVersion")
    def node_version(self) -> 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[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) -> 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, Any]:
        """
        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) -> 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) -> str:
        """
        The sub-network to use for the cluster
        """
        return pulumi.get(self, "sub_network")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[int]:
        """
        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[bool]:
        """
        To enable kubernetes alpha feature
        """
        return pulumi.get(self, "enable_alpha_feature")

    @property
    @pulumi.getter(name="enableAutoRepair")
    def enable_auto_repair(self) -> Optional[bool]:
        """
        Specifies whether the node auto-repair is enabled for the node pool
        """
        return pulumi.get(self, "enable_auto_repair")

    @property
    @pulumi.getter(name="enableAutoUpgrade")
    def enable_auto_upgrade(self) -> Optional[bool]:
        """
        Specifies whether node auto-upgrade is enabled for the node pool
        """
        return pulumi.get(self, "enable_auto_upgrade")

    @property
    @pulumi.getter(name="enableHorizontalPodAutoscaling")
    def enable_horizontal_pod_autoscaling(self) -> Optional[bool]:
        """
        Enable horizontal pod autoscaling for the cluster
        """
        return pulumi.get(self, "enable_horizontal_pod_autoscaling")

    @property
    @pulumi.getter(name="enableHttpLoadBalancing")
    def enable_http_load_balancing(self) -> Optional[bool]:
        """
        Enable http load balancing for the cluster
        """
        return pulumi.get(self, "enable_http_load_balancing")

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[bool]:
        """
        Whether to enable the kubernetes dashboard
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enableLegacyAbac")
    def enable_legacy_abac(self) -> Optional[bool]:
        """
        Whether to enable legacy abac on the cluster
        """
        return pulumi.get(self, "enable_legacy_abac")

    @property
    @pulumi.getter(name="enableMasterAuthorizedNetwork")
    def enable_master_authorized_network(self) -> Optional[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[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[bool]:
        """
        Enable nodepool autoscaling
        """
        return pulumi.get(self, "enable_nodepool_autoscaling")

    @property
    @pulumi.getter(name="enablePrivateEndpoint")
    def enable_private_endpoint(self) -> Optional[bool]:
        """
        Whether the master's internal IP address is used as the cluster endpoint
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[bool]:
        """
        Whether nodes have internal IP address only
        """
        return pulumi.get(self, "enable_private_nodes")

    @property
    @pulumi.getter(name="enableStackdriverLogging")
    def enable_stackdriver_logging(self) -> Optional[bool]:
        """
        Enable stackdriver logging
        """
        return pulumi.get(self, "enable_stackdriver_logging")

    @property
    @pulumi.getter(name="enableStackdriverMonitoring")
    def enable_stackdriver_monitoring(self) -> Optional[bool]:
        """
        Enable stackdriver monitoring
        """
        return pulumi.get(self, "enable_stackdriver_monitoring")

    @property
    @pulumi.getter(name="ipPolicyCreateSubnetwork")
    def ip_policy_create_subnetwork(self) -> Optional[bool]:
        """
        Whether a new subnetwork will be created automatically for the cluster
        """
        return pulumi.get(self, "ip_policy_create_subnetwork")

    @property
    @pulumi.getter(name="issueClientCertificate")
    def issue_client_certificate(self) -> Optional[bool]:
        """
        Issue a client certificate
        """
        return pulumi.get(self, "issue_client_certificate")

    @property
    @pulumi.getter(name="kubernetesDashboard")
    def kubernetes_dashboard(self) -> Optional[bool]:
        """
        Enable the kubernetes dashboard
        """
        return pulumi.get(self, "kubernetes_dashboard")

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[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[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[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[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[int]:
        """
        The number of nodes to create in this cluster
        """
        return pulumi.get(self, "node_count")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[bool]:
        """
        Whether the nodes are created as preemptible VM instances
        """
        return pulumi.get(self, "preemptible")

    @property
    @pulumi.getter
    def region(self) -> Optional[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[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[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[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: str,
                 description: str,
                 enable_kubernetes_alpha: bool,
                 google_credential_secret: str,
                 ip_allocation_policy: 'outputs.GetClusterGkeConfigV2IpAllocationPolicyResult',
                 kubernetes_version: str,
                 labels: Mapping[str, Any],
                 locations: Sequence[str],
                 logging_service: str,
                 maintenance_window: str,
                 master_authorized_networks_config: 'outputs.GetClusterGkeConfigV2MasterAuthorizedNetworksConfigResult',
                 monitoring_service: str,
                 name: str,
                 network: str,
                 network_policy_enabled: bool,
                 node_pools: Sequence['outputs.GetClusterGkeConfigV2NodePoolResult'],
                 private_cluster_config: 'outputs.GetClusterGkeConfigV2PrivateClusterConfigResult',
                 project_id: str,
                 region: str,
                 subnetwork: str,
                 zone: str,
                 imported: Optional[bool] = None):
        """
        :param 'GetClusterGkeConfigV2ClusterAddonsArgs' cluster_addons: The GKE cluster addons
        :param str cluster_ipv4_cidr_block: The GKE ip v4 cidr block
        :param str description: (Computed) The description for Cluster (string)
        :param bool enable_kubernetes_alpha: Enable Kubernetes alpha
        :param str google_credential_secret: Google credential secret
        :param 'GetClusterGkeConfigV2IpAllocationPolicyArgs' ip_allocation_policy: The GKE ip allocation policy
        :param str kubernetes_version: The kubernetes master version
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[str] locations: The GKE cluster locations
        :param str logging_service: The GKE cluster logging service
        :param str maintenance_window: The GKE cluster maintenance window
        :param 'GetClusterGkeConfigV2MasterAuthorizedNetworksConfigArgs' master_authorized_networks_config: The GKE cluster master authorized networks config
        :param str monitoring_service: The GKE cluster monitoring service
        :param str name: The name of the Cluster (string)
        :param str network: The GKE cluster network
        :param 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 str project_id: The GKE project id
        :param str region: The GKE cluster region. Required if `zone` is empty
        :param str subnetwork: The GKE cluster subnetwork
        :param str zone: The GKE cluster zone. Required if `region` is empty
        :param 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) -> str:
        """
        The GKE ip v4 cidr block
        """
        return pulumi.get(self, "cluster_ipv4_cidr_block")

    @property
    @pulumi.getter
    def description(self) -> str:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableKubernetesAlpha")
    def enable_kubernetes_alpha(self) -> bool:
        """
        Enable Kubernetes alpha
        """
        return pulumi.get(self, "enable_kubernetes_alpha")

    @property
    @pulumi.getter(name="googleCredentialSecret")
    def google_credential_secret(self) -> 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) -> str:
        """
        The kubernetes master version
        """
        return pulumi.get(self, "kubernetes_version")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def locations(self) -> Sequence[str]:
        """
        The GKE cluster locations
        """
        return pulumi.get(self, "locations")

    @property
    @pulumi.getter(name="loggingService")
    def logging_service(self) -> str:
        """
        The GKE cluster logging service
        """
        return pulumi.get(self, "logging_service")

    @property
    @pulumi.getter(name="maintenanceWindow")
    def maintenance_window(self) -> 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) -> str:
        """
        The GKE cluster monitoring service
        """
        return pulumi.get(self, "monitoring_service")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def network(self) -> str:
        """
        The GKE cluster network
        """
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="networkPolicyEnabled")
    def network_policy_enabled(self) -> 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) -> str:
        """
        The GKE project id
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def region(self) -> str:
        """
        The GKE cluster region. Required if `zone` is empty
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def subnetwork(self) -> str:
        """
        The GKE cluster subnetwork
        """
        return pulumi.get(self, "subnetwork")

    @property
    @pulumi.getter
    def zone(self) -> str:
        """
        The GKE cluster zone. Required if `region` is empty
        """
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter
    def imported(self) -> Optional[bool]:
        """
        Is GKE cluster imported?
        """
        return pulumi.get(self, "imported")


@pulumi.output_type
class GetClusterGkeConfigV2ClusterAddonsResult(dict):
    def __init__(__self__, *,
                 horizontal_pod_autoscaling: bool,
                 http_load_balancing: bool,
                 network_policy_config: bool):
        """
        :param bool horizontal_pod_autoscaling: Enable GKE horizontal pod autoscaling
        :param bool http_load_balancing: Enable GKE HTTP load balancing
        :param 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) -> bool:
        """
        Enable GKE horizontal pod autoscaling
        """
        return pulumi.get(self, "horizontal_pod_autoscaling")

    @property
    @pulumi.getter(name="httpLoadBalancing")
    def http_load_balancing(self) -> bool:
        """
        Enable GKE HTTP load balancing
        """
        return pulumi.get(self, "http_load_balancing")

    @property
    @pulumi.getter(name="networkPolicyConfig")
    def network_policy_config(self) -> 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: str,
                 cluster_secondary_range_name: str,
                 create_subnetwork: bool,
                 node_ipv4_cidr_block: str,
                 services_ipv4_cidr_block: str,
                 services_secondary_range_name: str,
                 subnetwork_name: str,
                 use_ip_aliases: bool):
        """
        :param str cluster_ipv4_cidr_block: The GKE cluster ip v4 allocation cidr block
        :param str cluster_secondary_range_name: The GKE cluster ip v4 allocation secondary range name
        :param bool create_subnetwork: Create GKE subnetwork?
        :param str node_ipv4_cidr_block: The GKE node ip v4 allocation cidr block
        :param str services_ipv4_cidr_block: The GKE services ip v4 allocation cidr block
        :param str services_secondary_range_name: The GKE services ip v4 allocation secondary range name
        :param str subnetwork_name: The GKE cluster subnetwork name
        :param 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) -> 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) -> 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) -> bool:
        """
        Create GKE subnetwork?
        """
        return pulumi.get(self, "create_subnetwork")

    @property
    @pulumi.getter(name="nodeIpv4CidrBlock")
    def node_ipv4_cidr_block(self) -> 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) -> 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) -> 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) -> str:
        """
        The GKE cluster subnetwork name
        """
        return pulumi.get(self, "subnetwork_name")

    @property
    @pulumi.getter(name="useIpAliases")
    def use_ip_aliases(self) -> 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[bool] = None):
        """
        :param Sequence['GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockArgs'] cidr_blocks: The GKE master authorized network config cidr blocks
        :param 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[bool]:
        """
        Enable GKE master authorized network config
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterGkeConfigV2MasterAuthorizedNetworksConfigCidrBlockResult(dict):
    def __init__(__self__, *,
                 cidr_block: str,
                 display_name: Optional[str] = None):
        """
        :param str cidr_block: The GKE master authorized network config cidr block
        :param 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) -> 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[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: int,
                 management: 'outputs.GetClusterGkeConfigV2NodePoolManagementResult',
                 max_pods_constraint: int,
                 name: str,
                 version: str):
        """
        :param 'GetClusterGkeConfigV2NodePoolAutoscalingArgs' autoscaling: The GKE node pool config autoscaling
        :param 'GetClusterGkeConfigV2NodePoolConfigArgs' config: The GKE node pool node config
        :param int initial_node_count: The GKE node pool config initial node count
        :param 'GetClusterGkeConfigV2NodePoolManagementArgs' management: The GKE node pool config management
        :param int max_pods_constraint: The GKE node pool config max pods constraint
        :param str name: The name of the Cluster (string)
        :param 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) -> 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) -> int:
        """
        The GKE node pool config max pods constraint
        """
        return pulumi.get(self, "max_pods_constraint")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def version(self) -> str:
        """
        The GKE node pool config version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolAutoscalingResult(dict):
    def __init__(__self__, *,
                 max_node_count: int,
                 min_node_count: int,
                 enabled: Optional[bool] = None):
        """
        :param int max_node_count: The GKE node pool config max node count
        :param int min_node_count: The GKE node pool config min node count
        :param 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) -> 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) -> int:
        """
        The GKE node pool config min node count
        """
        return pulumi.get(self, "min_node_count")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Enable GKE node pool config autoscaling
        """
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolConfigResult(dict):
    def __init__(__self__, *,
                 labels: Mapping[str, Any],
                 oauth_scopes: Sequence[str],
                 tags: Sequence[str],
                 disk_size_gb: Optional[int] = None,
                 disk_type: Optional[str] = None,
                 image_type: Optional[str] = None,
                 local_ssd_count: Optional[int] = None,
                 machine_type: Optional[str] = None,
                 preemptible: Optional[bool] = None,
                 taints: Optional[Sequence['outputs.GetClusterGkeConfigV2NodePoolConfigTaintResult']] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        :param Sequence[str] oauth_scopes: The GKE node config oauth scopes
        :param Sequence[str] tags: The GKE node config tags
        :param int disk_size_gb: The GKE node config disk size (Gb)
        :param str disk_type: The GKE node config disk type
        :param str image_type: The GKE node config image type
        :param int local_ssd_count: The GKE node config local ssd count
        :param str machine_type: The GKE node config machine type
        :param bool preemptible: Enable GKE node config preemptible
        :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 taints is not None:
            pulumi.set(__self__, "taints", taints)

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="oauthScopes")
    def oauth_scopes(self) -> Sequence[str]:
        """
        The GKE node config oauth scopes
        """
        return pulumi.get(self, "oauth_scopes")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        """
        The GKE node config tags
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[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[str]:
        """
        The GKE node config disk type
        """
        return pulumi.get(self, "disk_type")

    @property
    @pulumi.getter(name="imageType")
    def image_type(self) -> Optional[str]:
        """
        The GKE node config image type
        """
        return pulumi.get(self, "image_type")

    @property
    @pulumi.getter(name="localSsdCount")
    def local_ssd_count(self) -> Optional[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[str]:
        """
        The GKE node config machine type
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter
    def preemptible(self) -> Optional[bool]:
        """
        Enable GKE node config preemptible
        """
        return pulumi.get(self, "preemptible")

    @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: str,
                 key: str,
                 value: str):
        pulumi.set(__self__, "effect", effect)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def effect(self) -> str:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterGkeConfigV2NodePoolManagementResult(dict):
    def __init__(__self__, *,
                 auto_repair: bool,
                 auto_upgrade: bool):
        """
        :param bool auto_repair: Enable GKE node pool config management auto repair
        :param 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) -> bool:
        """
        Enable GKE node pool config management auto repair
        """
        return pulumi.get(self, "auto_repair")

    @property
    @pulumi.getter(name="autoUpgrade")
    def auto_upgrade(self) -> 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: str,
                 enable_private_endpoint: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None):
        """
        :param str master_ipv4_cidr_block: The GKE cluster private master ip v4 cidr block
        :param bool enable_private_endpoint: Enable GKE cluster private endpoint
        :param 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) -> 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[bool]:
        """
        Enable GKE cluster private endpoint
        """
        return pulumi.get(self, "enable_private_endpoint")

    @property
    @pulumi.getter(name="enablePrivateNodes")
    def enable_private_nodes(self) -> Optional[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: str):
        """
        :param 'GetClusterK3sConfigUpgradeStrategyArgs' upgrade_strategy: The K3S upgrade strategy
        :param 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) -> str:
        """
        The K3S kubernetes version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterK3sConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[int] = None,
                 worker_concurrency: Optional[int] = None):
        """
        :param bool drain_server_nodes: Drain server nodes
        :param bool drain_worker_nodes: Drain worker nodes
        :param int server_concurrency: Server concurrency
        :param 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[bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[bool]:
        """
        Drain worker nodes
        """
        return pulumi.get(self, "drain_worker_nodes")

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[int]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[int]:
        """
        Worker concurrency
        """
        return pulumi.get(self, "worker_concurrency")


@pulumi.output_type
class GetClusterOkeConfigResult(dict):
    def __init__(__self__, *,
                 compartment_id: str,
                 fingerprint: str,
                 kubernetes_version: str,
                 node_image: str,
                 node_shape: str,
                 private_key_contents: str,
                 region: str,
                 tenancy_id: str,
                 user_ocid: str,
                 custom_boot_volume_size: Optional[int] = None,
                 description: Optional[str] = None,
                 enable_kubernetes_dashboard: Optional[bool] = None,
                 enable_private_control_plane: Optional[bool] = None,
                 enable_private_nodes: Optional[bool] = None,
                 flex_ocpus: Optional[int] = None,
                 kms_key_id: Optional[str] = None,
                 limit_node_count: Optional[int] = None,
                 load_balancer_subnet_name1: Optional[str] = None,
                 load_balancer_subnet_name2: Optional[str] = None,
                 node_pool_dns_domain_name: Optional[str] = None,
                 node_pool_subnet_name: Optional[str] = None,
                 node_public_key_contents: Optional[str] = None,
                 pod_cidr: Optional[str] = None,
                 private_key_passphrase: Optional[str] = None,
                 quantity_of_node_subnets: Optional[int] = None,
                 quantity_per_subnet: Optional[int] = None,
                 service_cidr: Optional[str] = None,
                 service_dns_domain_name: Optional[str] = None,
                 skip_vcn_delete: Optional[bool] = None,
                 vcn_compartment_id: Optional[str] = None,
                 vcn_name: Optional[str] = None,
                 worker_node_ingress_cidr: Optional[str] = None):
        """
        :param str compartment_id: The OCID of the compartment in which to create resources (VCN, worker nodes, etc.)
        :param str fingerprint: The fingerprint corresponding to the specified user's private API Key
        :param str kubernetes_version: The Kubernetes version that will be used for your master *and* worker nodes e.g. v1.19.7
        :param str node_image: The OS for the node image
        :param str node_shape: The shape of the node (determines number of CPUs and  amount of memory on each node)
        :param str private_key_contents: The private API key file contents for the specified user, in PEM format
        :param str region: The availability domain within the region to host the OKE cluster
        :param str tenancy_id: The OCID of the tenancy in which to create resources
        :param str user_ocid: The OCID of a user who has access to the tenancy/compartment
        :param int custom_boot_volume_size: An optional custom boot volume size (in GB) for the nodes
        :param str description: (Computed) The description for Cluster (string)
        :param bool enable_kubernetes_dashboard: Enable the kubernetes dashboard
        :param bool enable_private_control_plane: Whether Kubernetes API endpoint is a private IP only accessible from within the VCN
        :param bool enable_private_nodes: Whether worker nodes are deployed into a new private subnet
        :param int flex_ocpus: Optional number of OCPUs for nodes (requires flexible node_shape)
        :param str kms_key_id: Optional specify the OCID of the KMS Vault master key
        :param int limit_node_count: Optional limit on the total number of nodes in the pool
        :param str load_balancer_subnet_name1: The name of the first existing subnet to use for Kubernetes services / LB
        :param str load_balancer_subnet_name2: The (optional) name of a second existing subnet to use for Kubernetes services / LB
        :param str node_pool_dns_domain_name: Optional name for DNS domain of node pool subnet
        :param str node_pool_subnet_name: Optional name for node pool subnet
        :param str node_public_key_contents: The contents of the SSH public key file to use for the nodes
        :param str pod_cidr: Optional specify the pod CIDR, defaults to 10.244.0.0/16
        :param str private_key_passphrase: The passphrase of the private key for the OKE cluster
        :param int quantity_of_node_subnets: Number of node subnets (defaults to creating 1 regional subnet)
        :param int quantity_per_subnet: Number of worker nodes in each subnet / availability domain
        :param str service_cidr: Optional specify the service CIDR, defaults to 10.96.0.0/16
        :param str service_dns_domain_name: Optional name for DNS domain of service subnet
        :param bool skip_vcn_delete: Whether to skip deleting VCN
        :param str vcn_compartment_id: The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        :param 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 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) -> 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) -> 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) -> 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) -> str:
        """
        The OS for the node image
        """
        return pulumi.get(self, "node_image")

    @property
    @pulumi.getter(name="nodeShape")
    def node_shape(self) -> str:
        """
        The shape of the node (determines number of CPUs and  amount of memory on each node)
        """
        return pulumi.get(self, "node_shape")

    @property
    @pulumi.getter(name="privateKeyContents")
    def private_key_contents(self) -> str:
        """
        The private API key file contents for the specified user, in PEM format
        """
        return pulumi.get(self, "private_key_contents")

    @property
    @pulumi.getter
    def region(self) -> 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) -> 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) -> 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[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[str]:
        """
        (Computed) The description for Cluster (string)
        """
        return pulumi.get(self, "description")

    @property
    @pulumi.getter(name="enableKubernetesDashboard")
    def enable_kubernetes_dashboard(self) -> Optional[bool]:
        """
        Enable the kubernetes dashboard
        """
        return pulumi.get(self, "enable_kubernetes_dashboard")

    @property
    @pulumi.getter(name="enablePrivateControlPlane")
    def enable_private_control_plane(self) -> Optional[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[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[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[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[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[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[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[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[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[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[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[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[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[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[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[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[bool]:
        """
        Whether to skip deleting VCN
        """
        return pulumi.get(self, "skip_vcn_delete")

    @property
    @pulumi.getter(name="vcnCompartmentId")
    def vcn_compartment_id(self) -> Optional[str]:
        """
        The OCID of the compartment (if different from compartment_id) in which to find the pre-existing virtual network set with vcn_name.
        """
        return pulumi.get(self, "vcn_compartment_id")

    @property
    @pulumi.getter(name="vcnName")
    def vcn_name(self) -> Optional[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[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: str):
        """
        :param 'GetClusterRke2ConfigUpgradeStrategyArgs' upgrade_strategy: The RKE2 upgrade strategy
        :param 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) -> str:
        """
        The RKE2 kubernetes version
        """
        return pulumi.get(self, "version")


@pulumi.output_type
class GetClusterRke2ConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_server_nodes: Optional[bool] = None,
                 drain_worker_nodes: Optional[bool] = None,
                 server_concurrency: Optional[int] = None,
                 worker_concurrency: Optional[int] = None):
        """
        :param bool drain_server_nodes: Drain server nodes
        :param bool drain_worker_nodes: Drain worker nodes
        :param int server_concurrency: Server concurrency
        :param 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[bool]:
        """
        Drain server nodes
        """
        return pulumi.get(self, "drain_server_nodes")

    @property
    @pulumi.getter(name="drainWorkerNodes")
    def drain_worker_nodes(self) -> Optional[bool]:
        """
        Drain worker nodes
        """
        return pulumi.get(self, "drain_worker_nodes")

    @property
    @pulumi.getter(name="serverConcurrency")
    def server_concurrency(self) -> Optional[int]:
        """
        Server concurrency
        """
        return pulumi.get(self, "server_concurrency")

    @property
    @pulumi.getter(name="workerConcurrency")
    def worker_concurrency(self) -> Optional[int]:
        """
        Worker concurrency
        """
        return pulumi.get(self, "worker_concurrency")


@pulumi.output_type
class GetClusterRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: int,
                 authentication: 'outputs.GetClusterRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterRkeConfigIngressResult',
                 kubernetes_version: str,
                 monitoring: 'outputs.GetClusterRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterRkeConfigNetworkResult',
                 prefix_path: str,
                 services: 'outputs.GetClusterRkeConfigServicesResult',
                 ssh_cert_path: str,
                 ssh_key_path: str,
                 upgrade_strategy: 'outputs.GetClusterRkeConfigUpgradeStrategyResult',
                 win_prefix_path: str,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['outputs.GetClusterRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param 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 str kubernetes_version: Optional kubernetes version to deploy
        :param 'GetClusterRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'GetClusterRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param str prefix_path: Optional prefix to customize kubernetes path
        :param 'GetClusterRkeConfigServicesArgs' services: Kubernetes cluster services
        :param str ssh_cert_path: Optional cluster level SSH certificate path
        :param str ssh_key_path: Optional cluster level SSH private key path
        :param 'GetClusterRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param str win_prefix_path: Optional prefix to customize kubernetes path for windows nodes
        :param str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param 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 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) -> 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) -> 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) -> 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) -> str:
        """
        Optional cluster level SSH certificate path
        """
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> 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) -> str:
        """
        Optional prefix to customize kubernetes path for windows nodes
        """
        return pulumi.get(self, "win_prefix_path")

    @property
    @pulumi.getter
    def addons(self) -> Optional[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[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[bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[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[bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: Sequence[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 mode: Optional[str] = None):
        pulumi.set(__self__, "options", options)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: str,
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: str,
                 aws_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[str] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderResult']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderAzureCloudProviderResult']:
        return pulumi.get(self, "azure_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderOpenstackCloudProviderResult']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderResult']:
        return pulumi.get(self, "vsphere_cloud_provider")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderResult(dict):
    def __init__(__self__, *,
                 global_: 'outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult',
                 service_overrides: Optional[Sequence['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']] = None):
        pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[Sequence['outputs.GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']]:
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 elb_security_group: str,
                 kubernetes_cluster_id: str,
                 kubernetes_cluster_tag: str,
                 role_arn: str,
                 route_table_id: str,
                 subnet_id: str,
                 vpc: str,
                 zone: str,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None):
        pulumi.set(__self__, "elb_security_group", elb_security_group)
        pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc", vpc)
        pulumi.set(__self__, "zone", zone)
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: str,
                 service: str,
                 signing_method: str,
                 signing_name: str,
                 signing_region: str,
                 url: str):
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "signing_method", signing_method)
        pulumi.set(__self__, "signing_name", signing_name)
        pulumi.set(__self__, "signing_region", signing_region)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: str,
                 aad_client_cert_path: str,
                 aad_client_id: str,
                 aad_client_secret: str,
                 cloud: str,
                 cloud_provider_backoff: bool,
                 cloud_provider_backoff_duration: int,
                 cloud_provider_backoff_exponent: int,
                 cloud_provider_backoff_jitter: int,
                 cloud_provider_backoff_retries: int,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: int,
                 cloud_provider_rate_limit_qps: int,
                 location: str,
                 maximum_load_balancer_rule_count: int,
                 primary_availability_set_name: str,
                 primary_scale_set_name: str,
                 resource_group: str,
                 route_table_name: str,
                 security_group_name: str,
                 subnet_name: str,
                 subscription_id: str,
                 tenant_id: str,
                 use_instance_metadata: bool,
                 use_managed_identity_extension: bool,
                 vm_type: str,
                 vnet_name: str,
                 vnet_resource_group: str,
                 load_balancer_sku: Optional[str] = None):
        """
        :param 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) -> str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> int:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        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: str,
                 ignore_volume_az: bool,
                 trust_device_path: bool):
        pulumi.set(__self__, "bs_version", bs_version)
        pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 ca_file: str,
                 domain_id: str,
                 domain_name: str,
                 password: str,
                 region: str,
                 tenant_id: str,
                 tenant_name: str,
                 trust_id: str,
                 username: str):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "ca_file", ca_file)
        pulumi.set(__self__, "domain_id", domain_id)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "tenant_name", tenant_name)
        pulumi.set(__self__, "trust_id", trust_id)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: bool,
                 floating_network_id: str,
                 lb_method: str,
                 lb_provider: str,
                 lb_version: str,
                 manage_security_groups: bool,
                 subnet_id: str,
                 use_octavia: bool,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[int] = None,
                 monitor_timeout: Optional[str] = None):
        pulumi.set(__self__, "create_monitor", create_monitor)
        pulumi.set(__self__, "floating_network_id", floating_network_id)
        pulumi.set(__self__, "lb_method", lb_method)
        pulumi.set(__self__, "lb_provider", lb_provider)
        pulumi.set(__self__, "lb_version", lb_version)
        pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "use_octavia", use_octavia)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[int]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: int,
                 search_order: str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> int:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        return pulumi.get(self, "router_id")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderResult(dict):
    def __init__(__self__, *,
                 disk: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult',
                 global_: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
                 network: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
                 virtual_centers: Sequence['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult'],
                 workspace: 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult'):
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)

    @property
    @pulumi.getter
    def disk(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult':
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> Sequence['outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult':
        return pulumi.get(self, "workspace")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderDiskResult(dict):
    def __init__(__self__, *,
                 scsi_controller_type: str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 insecure_flag: bool,
                 password: str,
                 port: str,
                 soap_roundtrip_count: int,
                 user: str,
                 graceful_shutdown_timeout: Optional[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) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[str]:
        return pulumi.get(self, "graceful_shutdown_timeout")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 port: str,
                 soap_roundtrip_count: int,
                 user: str):
        """
        :param str name: The name of the Cluster (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: str,
                 default_datastore: str,
                 folder: str,
                 resourcepool_path: str,
                 server: str):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "default_datastore", default_datastore)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "resourcepool_path", resourcepool_path)
        pulumi.set(__self__, "server", server)

    @property
    @pulumi.getter
    def datacenter(self) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 reverse_cidrs: Sequence[str],
                 upstream_nameservers: Sequence[str],
                 linear_autoscaler_params: Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyResult'] = None):
        """
        :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, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Sequence[str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterRkeConfigDnsLinearAutoscalerParamsResult']:
        """
        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[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[float] = None,
                 max: Optional[int] = None,
                 min: Optional[int] = None,
                 nodes_per_replica: Optional[float] = None,
                 prevent_single_point_failure: Optional[bool] = None):
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

    @property
    @pulumi.getter(name="coresPerReplica")
    def cores_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[int]:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[int]:
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "nodes_per_replica")

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[bool]:
        return pulumi.get(self, "prevent_single_point_failure")


@pulumi.output_type
class GetClusterRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterRkeConfigDnsTolerationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 http_port: int,
                 https_port: int,
                 network_mode: str,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str,
                 default_backend: Optional[bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyResult'] = None):
        """
        :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) -> str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> int:
        return pulumi.get(self, "http_port")

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> int:
        return pulumi.get(self, "https_port")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> str:
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter(name="defaultBackend")
    def default_backend(self) -> Optional[bool]:
        return pulumi.get(self, "default_backend")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigIngressTolerationResult']]:
        """
        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: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigIngressUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_unavailable: Optional[int] = None):
        """
        :param 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[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: int,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyResult'] = None):
        """
        :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, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> int:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterRkeConfigMonitoringTolerationResult']]:
        """
        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: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 plugin: 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[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, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> 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[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: str,
                 apic_hosts: Sequence[str],
                 apic_user_crt: str,
                 apic_user_key: str,
                 apic_user_name: str,
                 encap_type: str,
                 extern_dynamic: str,
                 extern_static: str,
                 kube_api_vlan: str,
                 l3out: str,
                 l3out_external_networks: Sequence[str],
                 mcast_range_end: str,
                 mcast_range_start: str,
                 node_subnet: str,
                 node_svc_subnet: str,
                 service_vlan: str,
                 system_id: str,
                 token: str,
                 vrf_name: str,
                 vrf_tenant: str,
                 apic_refresh_ticker_adjust: Optional[str] = None,
                 apic_refresh_time: Optional[str] = None,
                 apic_subscription_delay: Optional[str] = None,
                 capic: Optional[str] = None,
                 controller_log_level: Optional[str] = None,
                 disable_periodic_snat_global_info_sync: Optional[str] = None,
                 disable_wait_for_network: Optional[str] = None,
                 drop_log_enable: Optional[str] = None,
                 duration_wait_for_network: Optional[str] = None,
                 enable_endpoint_slice: Optional[str] = None,
                 ep_registry: Optional[str] = None,
                 gbp_pod_subnet: Optional[str] = None,
                 host_agent_log_level: Optional[str] = None,
                 image_pull_policy: Optional[str] = None,
                 image_pull_secret: Optional[str] = None,
                 infra_vlan: Optional[str] = None,
                 install_istio: Optional[str] = None,
                 istio_profile: Optional[str] = None,
                 kafka_brokers: Optional[Sequence[str]] = None,
                 kafka_client_crt: Optional[str] = None,
                 kafka_client_key: Optional[str] = None,
                 max_nodes_svc_graph: Optional[str] = None,
                 mtu_head_room: Optional[str] = None,
                 multus_disable: Optional[str] = None,
                 no_priority_class: Optional[str] = None,
                 node_pod_if_enable: Optional[str] = None,
                 opflex_client_ssl: Optional[str] = None,
                 opflex_device_delete_timeout: Optional[str] = None,
                 opflex_log_level: Optional[str] = None,
                 opflex_mode: Optional[str] = None,
                 opflex_server_port: Optional[str] = None,
                 overlay_vrf_name: Optional[str] = None,
                 ovs_memory_limit: Optional[str] = None,
                 pbr_tracking_non_snat: Optional[str] = None,
                 pod_subnet_chunk_size: Optional[str] = None,
                 run_gbp_container: Optional[str] = None,
                 run_opflex_server_container: Optional[str] = None,
                 service_monitor_interval: Optional[str] = None,
                 snat_contract_scope: Optional[str] = None,
                 snat_namespace: Optional[str] = None,
                 snat_port_range_end: Optional[str] = None,
                 snat_port_range_start: Optional[str] = None,
                 snat_ports_per_node: Optional[str] = None,
                 sriov_enable: Optional[str] = None,
                 subnet_domain_name: Optional[str] = None,
                 tenant: Optional[str] = None,
                 use_aci_anywhere_crd: Optional[str] = None,
                 use_aci_cni_priority_class: Optional[str] = None,
                 use_cluster_role: Optional[str] = None,
                 use_host_netns_volume: Optional[str] = None,
                 use_opflex_server_volume: Optional[str] = None,
                 use_privileged_container: Optional[str] = None,
                 vmm_controller: Optional[str] = None,
                 vmm_domain: Optional[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) -> str:
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[str]:
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> str:
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> str:
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> str:
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> str:
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> str:
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> str:
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> str:
        return pulumi.get(self, "kube_api_vlan")

    @property
    @pulumi.getter
    def l3out(self) -> str:
        return pulumi.get(self, "l3out")

    @property
    @pulumi.getter(name="l3outExternalNetworks")
    def l3out_external_networks(self) -> Sequence[str]:
        return pulumi.get(self, "l3out_external_networks")

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> str:
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> str:
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> str:
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> str:
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> str:
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> str:
        return pulumi.get(self, "system_id")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> str:
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> str:
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[str]:
        return pulumi.get(self, "apic_subscription_delay")

    @property
    @pulumi.getter
    def capic(self) -> Optional[str]:
        return pulumi.get(self, "capic")

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[str]:
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[str]:
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[str]:
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[str]:
        return pulumi.get(self, "enable_endpoint_slice")

    @property
    @pulumi.getter(name="epRegistry")
    def ep_registry(self) -> Optional[str]:
        return pulumi.get(self, "ep_registry")

    @property
    @pulumi.getter(name="gbpPodSubnet")
    def gbp_pod_subnet(self) -> Optional[str]:
        return pulumi.get(self, "gbp_pod_subnet")

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[str]:
        return pulumi.get(self, "host_agent_log_level")

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_policy")

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_secret")

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[str]:
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[str]:
        return pulumi.get(self, "install_istio")

    @property
    @pulumi.getter(name="istioProfile")
    def istio_profile(self) -> Optional[str]:
        return pulumi.get(self, "istio_profile")

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "kafka_brokers")

    @property
    @pulumi.getter(name="kafkaClientCrt")
    def kafka_client_crt(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_crt")

    @property
    @pulumi.getter(name="kafkaClientKey")
    def kafka_client_key(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_key")

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[str]:
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[str]:
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[str]:
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[str]:
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[str]:
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[str]:
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[str]:
        return pulumi.get(self, "opflex_log_level")

    @property
    @pulumi.getter(name="opflexMode")
    def opflex_mode(self) -> Optional[str]:
        return pulumi.get(self, "opflex_mode")

    @property
    @pulumi.getter(name="opflexServerPort")
    def opflex_server_port(self) -> Optional[str]:
        return pulumi.get(self, "opflex_server_port")

    @property
    @pulumi.getter(name="overlayVrfName")
    def overlay_vrf_name(self) -> Optional[str]:
        return pulumi.get(self, "overlay_vrf_name")

    @property
    @pulumi.getter(name="ovsMemoryLimit")
    def ovs_memory_limit(self) -> Optional[str]:
        return pulumi.get(self, "ovs_memory_limit")

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[str]:
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[str]:
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[str]:
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[str]:
        return pulumi.get(self, "run_opflex_server_container")

    @property
    @pulumi.getter(name="serviceMonitorInterval")
    def service_monitor_interval(self) -> Optional[str]:
        return pulumi.get(self, "service_monitor_interval")

    @property
    @pulumi.getter(name="snatContractScope")
    def snat_contract_scope(self) -> Optional[str]:
        return pulumi.get(self, "snat_contract_scope")

    @property
    @pulumi.getter(name="snatNamespace")
    def snat_namespace(self) -> Optional[str]:
        return pulumi.get(self, "snat_namespace")

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[str]:
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[str]:
        return pulumi.get(self, "sriov_enable")

    @property
    @pulumi.getter(name="subnetDomainName")
    def subnet_domain_name(self) -> Optional[str]:
        return pulumi.get(self, "subnet_domain_name")

    @property
    @pulumi.getter
    def tenant(self) -> Optional[str]:
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[str]:
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[str]:
        return pulumi.get(self, "use_privileged_container")

    @property
    @pulumi.getter(name="vmmController")
    def vmm_controller(self) -> Optional[str]:
        return pulumi.get(self, "vmm_controller")

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[str]:
        return pulumi.get(self, "vmm_domain")


@pulumi.output_type
class GetClusterRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterRkeConfigNetworkTolerationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: str,
                 docker_socket: str,
                 roles: Sequence[str],
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for Node Pool object (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "docker_socket", docker_socket)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        (Computed) Labels for Node Pool object (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :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) -> 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[bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

    @property
    @pulumi.getter(name="awsAccessKeyId")
    def aws_access_key_id(self) -> Optional[str]:
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> Optional[str]:
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[str]:
        return pulumi.get(self, "aws_session_token")


@pulumi.output_type
class GetClusterRkeConfigServicesResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterRkeConfigServicesEtcdResult',
                 kube_api: 'outputs.GetClusterRkeConfigServicesKubeApiResult',
                 kube_controller: 'outputs.GetClusterRkeConfigServicesKubeControllerResult',
                 kubelet: 'outputs.GetClusterRkeConfigServicesKubeletResult',
                 kubeproxy: 'outputs.GetClusterRkeConfigServicesKubeproxyResult',
                 scheduler: 'outputs.GetClusterRkeConfigServicesSchedulerResult'):
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "kube_api", kube_api)
        pulumi.set(__self__, "kube_controller", kube_controller)
        pulumi.set(__self__, "kubelet", kubelet)
        pulumi.set(__self__, "kubeproxy", kubeproxy)
        pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterRkeConfigServicesEtcdResult':
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> 'outputs.GetClusterRkeConfigServicesKubeApiResult':
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> 'outputs.GetClusterRkeConfigServicesKubeControllerResult':
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> 'outputs.GetClusterRkeConfigServicesKubeletResult':
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> 'outputs.GetClusterRkeConfigServicesKubeproxyResult':
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> 'outputs.GetClusterRkeConfigServicesSchedulerResult':
        return pulumi.get(self, "scheduler")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdResult(dict):
    def __init__(__self__, *,
                 backup_config: 'outputs.GetClusterRkeConfigServicesEtcdBackupConfigResult',
                 ca_cert: str,
                 cert: str,
                 creation: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 key: str,
                 path: str,
                 retention: str,
                 snapshot: bool,
                 external_urls: Optional[Sequence[str]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 uid: Optional[int] = None):
        """
        :param str ca_cert: (Computed) K8s cluster ca cert (string)
        """
        pulumi.set(__self__, "backup_config", backup_config)
        pulumi.set(__self__, "ca_cert", ca_cert)
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "creation", creation)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "retention", retention)
        pulumi.set(__self__, "snapshot", snapshot)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> 'outputs.GetClusterRkeConfigServicesEtcdBackupConfigResult':
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> str:
        """
        (Computed) K8s cluster ca cert (string)
        """
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[int]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[int]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def timeout(self) -> int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 service_node_port_range: str,
                 admission_configuration: Optional['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult'] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.GetClusterRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        """
        :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 pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiAuditLogResult']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiEventRateLimitResult']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAdmissionConfigurationResult(dict):
    def __init__(__self__, *,
                 plugins: Sequence['outputs.GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult'],
                 api_version: Optional[str] = None,
                 kind: Optional[str] = None):
        """
        :param Sequence['GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        :param str api_version: Admission configuration ApiVersion
        :param 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[str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[str]:
        """
        Admission configuration Kind
        """
        return pulumi.get(self, "kind")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAdmissionConfigurationPluginResult(dict):
    def __init__(__self__, *,
                 configuration: str,
                 name: str,
                 path: Optional[str] = None):
        """
        :param str configuration: Plugin configuration
        :param str name: The name of the Cluster (string)
        :param 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) -> str:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> 'outputs.GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult':
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: str,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = None,
                 path: Optional[str] = None):
        pulumi.set(__self__, "policy", policy)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def policy(self) -> str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 configuration: str,
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> str:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: str,
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> str:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: str,
                 cluster_domain: str,
                 extra_args: Mapping[str, Any],
                 fail_swap_on: bool,
                 image: str,
                 infra_container_image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 generate_serving_certificate: Optional[bool] = None):
        pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        pulumi.set(__self__, "cluster_domain", cluster_domain)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "infra_container_image", infra_container_image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[bool] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        pulumi.set(__self__, "drain_input", drain_input)
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> 'outputs.GetClusterRkeConfigUpgradeStrategyDrainInputResult':
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterTemplateMemberResult(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type: member, owner, read-only
        :param str group_principal_id: Member group principal id
        :param 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[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[str]:
        """
        Member group principal id
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        """
        Member user principal id
        """
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigResult',
                 cluster_template_id: str,
                 id: str,
                 labels: Mapping[str, Any],
                 name: str,
                 default: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 questions: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionQuestionResult']] = None):
        """
        :param Mapping[str, Any] annotations: (Computed) Annotations for the cluster template (map)
        :param 'GetClusterTemplateTemplateRevisionClusterConfigArgs' cluster_config: Cluster configuration
        :param str cluster_template_id: Cluster template ID
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: (Computed) Labels for the cluster template (map)
        :param str name: The cluster template name (string)
        :param bool default: Default cluster template revision
        :param 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, Any]:
        """
        (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) -> str:
        """
        Cluster template ID
        """
        return pulumi.get(self, "cluster_template_id")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def default(self) -> Optional[bool]:
        """
        Default cluster template revision
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[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: str,
                 default_pod_security_admission_configuration_template_name: str,
                 default_pod_security_policy_template_id: str,
                 desired_agent_image: str,
                 desired_auth_image: str,
                 docker_root_dir: str,
                 rke_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult',
                 enable_cluster_alerting: Optional[bool] = None,
                 enable_cluster_monitoring: Optional[bool] = None,
                 enable_network_policy: Optional[bool] = None,
                 windows_prefered_cluster: Optional[bool] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointArgs' cluster_auth_endpoint: Local cluster auth endpoint
        :param str default_cluster_role_for_project_members: Default cluster role for project members
        :param str default_pod_security_admission_configuration_template_name: Default pod security admission configuration template name
        :param str default_pod_security_policy_template_id: Default pod security policy template ID
        :param str desired_agent_image: Desired agent image
        :param str desired_auth_image: Desired auth image
        :param str docker_root_dir: Docker Root Dir
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigArgs' rke_config: Rancher Kubernetes Engine Config
        :param bool enable_cluster_alerting: Enable built-in cluster alerting
        :param bool enable_cluster_monitoring: Enable built-in cluster monitoring
        :param bool enable_network_policy: Enable project network isolation
        :param 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__, "default_pod_security_policy_template_id", default_pod_security_policy_template_id)
        pulumi.set(__self__, "desired_agent_image", desired_agent_image)
        pulumi.set(__self__, "desired_auth_image", desired_auth_image)
        pulumi.set(__self__, "docker_root_dir", docker_root_dir)
        pulumi.set(__self__, "rke_config", rke_config)
        if enable_cluster_alerting is not None:
            pulumi.set(__self__, "enable_cluster_alerting", enable_cluster_alerting)
        if enable_cluster_monitoring is not None:
            pulumi.set(__self__, "enable_cluster_monitoring", enable_cluster_monitoring)
        if enable_network_policy is not None:
            pulumi.set(__self__, "enable_network_policy", enable_network_policy)
        if 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) -> 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) -> str:
        """
        Default pod security admission configuration template name
        """
        return pulumi.get(self, "default_pod_security_admission_configuration_template_name")

    @property
    @pulumi.getter(name="defaultPodSecurityPolicyTemplateId")
    def default_pod_security_policy_template_id(self) -> str:
        """
        Default pod security policy template ID
        """
        return pulumi.get(self, "default_pod_security_policy_template_id")

    @property
    @pulumi.getter(name="desiredAgentImage")
    def desired_agent_image(self) -> str:
        """
        Desired agent image
        """
        return pulumi.get(self, "desired_agent_image")

    @property
    @pulumi.getter(name="desiredAuthImage")
    def desired_auth_image(self) -> str:
        """
        Desired auth image
        """
        return pulumi.get(self, "desired_auth_image")

    @property
    @pulumi.getter(name="dockerRootDir")
    def docker_root_dir(self) -> 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="enableClusterAlerting")
    def enable_cluster_alerting(self) -> Optional[bool]:
        """
        Enable built-in cluster alerting
        """
        return pulumi.get(self, "enable_cluster_alerting")

    @property
    @pulumi.getter(name="enableClusterMonitoring")
    def enable_cluster_monitoring(self) -> Optional[bool]:
        """
        Enable built-in cluster monitoring
        """
        return pulumi.get(self, "enable_cluster_monitoring")

    @property
    @pulumi.getter(name="enableNetworkPolicy")
    def enable_network_policy(self) -> Optional[bool]:
        """
        Enable project network isolation
        """
        return pulumi.get(self, "enable_network_policy")

    @property
    @pulumi.getter(name="windowsPreferedCluster")
    def windows_prefered_cluster(self) -> Optional[bool]:
        """
        Windows prefered cluster
        """
        return pulumi.get(self, "windows_prefered_cluster")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigClusterAuthEndpointResult(dict):
    def __init__(__self__, *,
                 ca_certs: Optional[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigResult(dict):
    def __init__(__self__, *,
                 addon_job_timeout: int,
                 authentication: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult',
                 authorization: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult',
                 bastion_host: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult',
                 cloud_provider: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult',
                 dns: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult',
                 ingress: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult',
                 kubernetes_version: str,
                 monitoring: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult',
                 network: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult',
                 prefix_path: str,
                 services: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult',
                 ssh_cert_path: str,
                 ssh_key_path: str,
                 upgrade_strategy: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult',
                 win_prefix_path: str,
                 addons: Optional[str] = None,
                 addons_includes: Optional[Sequence[str]] = None,
                 enable_cri_dockerd: Optional[bool] = None,
                 ignore_docker_version: Optional[bool] = None,
                 nodes: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult']] = None,
                 private_registries: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult']] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param 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 str kubernetes_version: Optional kubernetes version to deploy
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringArgs' monitoring: Kubernetes cluster monitoring
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkArgs' network: Kubernetes cluster networking
        :param str prefix_path: Optional prefix to customize kubernetes path
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesArgs' services: Kubernetes cluster services
        :param str ssh_cert_path: Optional cluster level SSH certificate path
        :param str ssh_key_path: Optional cluster level SSH private key path
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyArgs' upgrade_strategy: RKE upgrade strategy
        :param str win_prefix_path: Optional prefix to customize kubernetes path for windows nodes
        :param str addons: Optional addons descripton to deploy on rke cluster.
        :param Sequence[str] addons_includes: Optional addons yaml manisfest to deploy on rke cluster.
        :param bool enable_cri_dockerd: Enable/disable using cri-dockerd
        :param 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 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) -> 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) -> 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) -> 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) -> str:
        """
        Optional cluster level SSH certificate path
        """
        return pulumi.get(self, "ssh_cert_path")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> 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) -> str:
        """
        Optional prefix to customize kubernetes path for windows nodes
        """
        return pulumi.get(self, "win_prefix_path")

    @property
    @pulumi.getter
    def addons(self) -> Optional[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[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[bool]:
        """
        Enable/disable using cri-dockerd
        """
        return pulumi.get(self, "enable_cri_dockerd")

    @property
    @pulumi.getter(name="ignoreDockerVersion")
    def ignore_docker_version(self) -> Optional[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[bool]:
        """
        Optional use ssh agent auth
        """
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthenticationResult(dict):
    def __init__(__self__, *,
                 sans: Sequence[str],
                 strategy: str):
        pulumi.set(__self__, "sans", sans)
        pulumi.set(__self__, "strategy", strategy)

    @property
    @pulumi.getter
    def sans(self) -> Sequence[str]:
        return pulumi.get(self, "sans")

    @property
    @pulumi.getter
    def strategy(self) -> str:
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigAuthorizationResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 mode: Optional[str] = None):
        pulumi.set(__self__, "options", options)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigBastionHostResult(dict):
    def __init__(__self__, *,
                 address: str,
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderResult(dict):
    def __init__(__self__, *,
                 custom_cloud_provider: str,
                 aws_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult'] = None,
                 azure_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult'] = None,
                 name: Optional[str] = None,
                 openstack_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult'] = None,
                 vsphere_cloud_provider: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult'] = None):
        """
        :param str name: The cluster template name (string)
        """
        pulumi.set(__self__, "custom_cloud_provider", custom_cloud_provider)
        if aws_cloud_provider is not None:
            pulumi.set(__self__, "aws_cloud_provider", aws_cloud_provider)
        if azure_cloud_provider is not None:
            pulumi.set(__self__, "azure_cloud_provider", azure_cloud_provider)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if openstack_cloud_provider is not None:
            pulumi.set(__self__, "openstack_cloud_provider", openstack_cloud_provider)
        if vsphere_cloud_provider is not None:
            pulumi.set(__self__, "vsphere_cloud_provider", vsphere_cloud_provider)

    @property
    @pulumi.getter(name="customCloudProvider")
    def custom_cloud_provider(self) -> str:
        return pulumi.get(self, "custom_cloud_provider")

    @property
    @pulumi.getter(name="awsCloudProvider")
    def aws_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult']:
        return pulumi.get(self, "aws_cloud_provider")

    @property
    @pulumi.getter(name="azureCloudProvider")
    def azure_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult']:
        return pulumi.get(self, "azure_cloud_provider")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="openstackCloudProvider")
    def openstack_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderResult']:
        return pulumi.get(self, "openstack_cloud_provider")

    @property
    @pulumi.getter(name="vsphereCloudProvider")
    def vsphere_cloud_provider(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult']:
        return pulumi.get(self, "vsphere_cloud_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderResult(dict):
    def __init__(__self__, *,
                 global_: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult',
                 service_overrides: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']] = None):
        pulumi.set(__self__, "global_", global_)
        if service_overrides is not None:
            pulumi.set(__self__, "service_overrides", service_overrides)

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter(name="serviceOverrides")
    def service_overrides(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult']]:
        return pulumi.get(self, "service_overrides")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 elb_security_group: str,
                 kubernetes_cluster_id: str,
                 kubernetes_cluster_tag: str,
                 role_arn: str,
                 route_table_id: str,
                 subnet_id: str,
                 vpc: str,
                 zone: str,
                 disable_security_group_ingress: Optional[bool] = None,
                 disable_strict_zone_check: Optional[bool] = None):
        pulumi.set(__self__, "elb_security_group", elb_security_group)
        pulumi.set(__self__, "kubernetes_cluster_id", kubernetes_cluster_id)
        pulumi.set(__self__, "kubernetes_cluster_tag", kubernetes_cluster_tag)
        pulumi.set(__self__, "role_arn", role_arn)
        pulumi.set(__self__, "route_table_id", route_table_id)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "vpc", vpc)
        pulumi.set(__self__, "zone", zone)
        if disable_security_group_ingress is not None:
            pulumi.set(__self__, "disable_security_group_ingress", disable_security_group_ingress)
        if disable_strict_zone_check is not None:
            pulumi.set(__self__, "disable_strict_zone_check", disable_strict_zone_check)

    @property
    @pulumi.getter(name="elbSecurityGroup")
    def elb_security_group(self) -> str:
        return pulumi.get(self, "elb_security_group")

    @property
    @pulumi.getter(name="kubernetesClusterId")
    def kubernetes_cluster_id(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_id")

    @property
    @pulumi.getter(name="kubernetesClusterTag")
    def kubernetes_cluster_tag(self) -> str:
        return pulumi.get(self, "kubernetes_cluster_tag")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> str:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="routeTableId")
    def route_table_id(self) -> str:
        return pulumi.get(self, "route_table_id")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter
    def vpc(self) -> str:
        return pulumi.get(self, "vpc")

    @property
    @pulumi.getter
    def zone(self) -> str:
        return pulumi.get(self, "zone")

    @property
    @pulumi.getter(name="disableSecurityGroupIngress")
    def disable_security_group_ingress(self) -> Optional[bool]:
        return pulumi.get(self, "disable_security_group_ingress")

    @property
    @pulumi.getter(name="disableStrictZoneCheck")
    def disable_strict_zone_check(self) -> Optional[bool]:
        return pulumi.get(self, "disable_strict_zone_check")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAwsCloudProviderServiceOverrideResult(dict):
    def __init__(__self__, *,
                 region: str,
                 service: str,
                 signing_method: str,
                 signing_name: str,
                 signing_region: str,
                 url: str):
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "service", service)
        pulumi.set(__self__, "signing_method", signing_method)
        pulumi.set(__self__, "signing_name", signing_name)
        pulumi.set(__self__, "signing_region", signing_region)
        pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter
    def service(self) -> str:
        return pulumi.get(self, "service")

    @property
    @pulumi.getter(name="signingMethod")
    def signing_method(self) -> str:
        return pulumi.get(self, "signing_method")

    @property
    @pulumi.getter(name="signingName")
    def signing_name(self) -> str:
        return pulumi.get(self, "signing_name")

    @property
    @pulumi.getter(name="signingRegion")
    def signing_region(self) -> str:
        return pulumi.get(self, "signing_region")

    @property
    @pulumi.getter
    def url(self) -> str:
        return pulumi.get(self, "url")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderAzureCloudProviderResult(dict):
    def __init__(__self__, *,
                 aad_client_cert_password: str,
                 aad_client_cert_path: str,
                 aad_client_id: str,
                 aad_client_secret: str,
                 cloud: str,
                 cloud_provider_backoff: bool,
                 cloud_provider_backoff_duration: int,
                 cloud_provider_backoff_exponent: int,
                 cloud_provider_backoff_jitter: int,
                 cloud_provider_backoff_retries: int,
                 cloud_provider_rate_limit: bool,
                 cloud_provider_rate_limit_bucket: int,
                 cloud_provider_rate_limit_qps: int,
                 location: str,
                 maximum_load_balancer_rule_count: int,
                 primary_availability_set_name: str,
                 primary_scale_set_name: str,
                 resource_group: str,
                 route_table_name: str,
                 security_group_name: str,
                 subnet_name: str,
                 subscription_id: str,
                 tenant_id: str,
                 use_instance_metadata: bool,
                 use_managed_identity_extension: bool,
                 vm_type: str,
                 vnet_name: str,
                 vnet_resource_group: str,
                 load_balancer_sku: Optional[str] = None):
        """
        :param 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) -> str:
        return pulumi.get(self, "aad_client_cert_password")

    @property
    @pulumi.getter(name="aadClientCertPath")
    def aad_client_cert_path(self) -> str:
        return pulumi.get(self, "aad_client_cert_path")

    @property
    @pulumi.getter(name="aadClientId")
    def aad_client_id(self) -> str:
        return pulumi.get(self, "aad_client_id")

    @property
    @pulumi.getter(name="aadClientSecret")
    def aad_client_secret(self) -> str:
        return pulumi.get(self, "aad_client_secret")

    @property
    @pulumi.getter
    def cloud(self) -> str:
        return pulumi.get(self, "cloud")

    @property
    @pulumi.getter(name="cloudProviderBackoff")
    def cloud_provider_backoff(self) -> bool:
        return pulumi.get(self, "cloud_provider_backoff")

    @property
    @pulumi.getter(name="cloudProviderBackoffDuration")
    def cloud_provider_backoff_duration(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_duration")

    @property
    @pulumi.getter(name="cloudProviderBackoffExponent")
    def cloud_provider_backoff_exponent(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_exponent")

    @property
    @pulumi.getter(name="cloudProviderBackoffJitter")
    def cloud_provider_backoff_jitter(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_jitter")

    @property
    @pulumi.getter(name="cloudProviderBackoffRetries")
    def cloud_provider_backoff_retries(self) -> int:
        return pulumi.get(self, "cloud_provider_backoff_retries")

    @property
    @pulumi.getter(name="cloudProviderRateLimit")
    def cloud_provider_rate_limit(self) -> bool:
        return pulumi.get(self, "cloud_provider_rate_limit")

    @property
    @pulumi.getter(name="cloudProviderRateLimitBucket")
    def cloud_provider_rate_limit_bucket(self) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_bucket")

    @property
    @pulumi.getter(name="cloudProviderRateLimitQps")
    def cloud_provider_rate_limit_qps(self) -> int:
        return pulumi.get(self, "cloud_provider_rate_limit_qps")

    @property
    @pulumi.getter
    def location(self) -> str:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter(name="maximumLoadBalancerRuleCount")
    def maximum_load_balancer_rule_count(self) -> int:
        return pulumi.get(self, "maximum_load_balancer_rule_count")

    @property
    @pulumi.getter(name="primaryAvailabilitySetName")
    def primary_availability_set_name(self) -> str:
        return pulumi.get(self, "primary_availability_set_name")

    @property
    @pulumi.getter(name="primaryScaleSetName")
    def primary_scale_set_name(self) -> str:
        return pulumi.get(self, "primary_scale_set_name")

    @property
    @pulumi.getter(name="resourceGroup")
    def resource_group(self) -> str:
        return pulumi.get(self, "resource_group")

    @property
    @pulumi.getter(name="routeTableName")
    def route_table_name(self) -> str:
        return pulumi.get(self, "route_table_name")

    @property
    @pulumi.getter(name="securityGroupName")
    def security_group_name(self) -> str:
        return pulumi.get(self, "security_group_name")

    @property
    @pulumi.getter(name="subnetName")
    def subnet_name(self) -> str:
        return pulumi.get(self, "subnet_name")

    @property
    @pulumi.getter(name="subscriptionId")
    def subscription_id(self) -> str:
        return pulumi.get(self, "subscription_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="useInstanceMetadata")
    def use_instance_metadata(self) -> bool:
        return pulumi.get(self, "use_instance_metadata")

    @property
    @pulumi.getter(name="useManagedIdentityExtension")
    def use_managed_identity_extension(self) -> bool:
        return pulumi.get(self, "use_managed_identity_extension")

    @property
    @pulumi.getter(name="vmType")
    def vm_type(self) -> str:
        return pulumi.get(self, "vm_type")

    @property
    @pulumi.getter(name="vnetName")
    def vnet_name(self) -> str:
        return pulumi.get(self, "vnet_name")

    @property
    @pulumi.getter(name="vnetResourceGroup")
    def vnet_resource_group(self) -> str:
        return pulumi.get(self, "vnet_resource_group")

    @property
    @pulumi.getter(name="loadBalancerSku")
    def load_balancer_sku(self) -> Optional[str]:
        """
        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: str,
                 ignore_volume_az: bool,
                 trust_device_path: bool):
        pulumi.set(__self__, "bs_version", bs_version)
        pulumi.set(__self__, "ignore_volume_az", ignore_volume_az)
        pulumi.set(__self__, "trust_device_path", trust_device_path)

    @property
    @pulumi.getter(name="bsVersion")
    def bs_version(self) -> str:
        return pulumi.get(self, "bs_version")

    @property
    @pulumi.getter(name="ignoreVolumeAz")
    def ignore_volume_az(self) -> bool:
        return pulumi.get(self, "ignore_volume_az")

    @property
    @pulumi.getter(name="trustDevicePath")
    def trust_device_path(self) -> bool:
        return pulumi.get(self, "trust_device_path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 auth_url: str,
                 ca_file: str,
                 domain_id: str,
                 domain_name: str,
                 password: str,
                 region: str,
                 tenant_id: str,
                 tenant_name: str,
                 trust_id: str,
                 username: str):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "ca_file", ca_file)
        pulumi.set(__self__, "domain_id", domain_id)
        pulumi.set(__self__, "domain_name", domain_name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "tenant_id", tenant_id)
        pulumi.set(__self__, "tenant_name", tenant_name)
        pulumi.set(__self__, "trust_id", trust_id)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> str:
        return pulumi.get(self, "auth_url")

    @property
    @pulumi.getter(name="caFile")
    def ca_file(self) -> str:
        return pulumi.get(self, "ca_file")

    @property
    @pulumi.getter(name="domainId")
    def domain_id(self) -> str:
        return pulumi.get(self, "domain_id")

    @property
    @pulumi.getter(name="domainName")
    def domain_name(self) -> str:
        return pulumi.get(self, "domain_name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def region(self) -> str:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        return pulumi.get(self, "tenant_id")

    @property
    @pulumi.getter(name="tenantName")
    def tenant_name(self) -> str:
        return pulumi.get(self, "tenant_name")

    @property
    @pulumi.getter(name="trustId")
    def trust_id(self) -> str:
        return pulumi.get(self, "trust_id")

    @property
    @pulumi.getter
    def username(self) -> str:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderLoadBalancerResult(dict):
    def __init__(__self__, *,
                 create_monitor: bool,
                 floating_network_id: str,
                 lb_method: str,
                 lb_provider: str,
                 lb_version: str,
                 manage_security_groups: bool,
                 subnet_id: str,
                 use_octavia: bool,
                 monitor_delay: Optional[str] = None,
                 monitor_max_retries: Optional[int] = None,
                 monitor_timeout: Optional[str] = None):
        pulumi.set(__self__, "create_monitor", create_monitor)
        pulumi.set(__self__, "floating_network_id", floating_network_id)
        pulumi.set(__self__, "lb_method", lb_method)
        pulumi.set(__self__, "lb_provider", lb_provider)
        pulumi.set(__self__, "lb_version", lb_version)
        pulumi.set(__self__, "manage_security_groups", manage_security_groups)
        pulumi.set(__self__, "subnet_id", subnet_id)
        pulumi.set(__self__, "use_octavia", use_octavia)
        if monitor_delay is not None:
            pulumi.set(__self__, "monitor_delay", monitor_delay)
        if monitor_max_retries is not None:
            pulumi.set(__self__, "monitor_max_retries", monitor_max_retries)
        if monitor_timeout is not None:
            pulumi.set(__self__, "monitor_timeout", monitor_timeout)

    @property
    @pulumi.getter(name="createMonitor")
    def create_monitor(self) -> bool:
        return pulumi.get(self, "create_monitor")

    @property
    @pulumi.getter(name="floatingNetworkId")
    def floating_network_id(self) -> str:
        return pulumi.get(self, "floating_network_id")

    @property
    @pulumi.getter(name="lbMethod")
    def lb_method(self) -> str:
        return pulumi.get(self, "lb_method")

    @property
    @pulumi.getter(name="lbProvider")
    def lb_provider(self) -> str:
        return pulumi.get(self, "lb_provider")

    @property
    @pulumi.getter(name="lbVersion")
    def lb_version(self) -> str:
        return pulumi.get(self, "lb_version")

    @property
    @pulumi.getter(name="manageSecurityGroups")
    def manage_security_groups(self) -> bool:
        return pulumi.get(self, "manage_security_groups")

    @property
    @pulumi.getter(name="subnetId")
    def subnet_id(self) -> str:
        return pulumi.get(self, "subnet_id")

    @property
    @pulumi.getter(name="useOctavia")
    def use_octavia(self) -> bool:
        return pulumi.get(self, "use_octavia")

    @property
    @pulumi.getter(name="monitorDelay")
    def monitor_delay(self) -> Optional[str]:
        return pulumi.get(self, "monitor_delay")

    @property
    @pulumi.getter(name="monitorMaxRetries")
    def monitor_max_retries(self) -> Optional[int]:
        return pulumi.get(self, "monitor_max_retries")

    @property
    @pulumi.getter(name="monitorTimeout")
    def monitor_timeout(self) -> Optional[str]:
        return pulumi.get(self, "monitor_timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderMetadataResult(dict):
    def __init__(__self__, *,
                 request_timeout: int,
                 search_order: str):
        pulumi.set(__self__, "request_timeout", request_timeout)
        pulumi.set(__self__, "search_order", search_order)

    @property
    @pulumi.getter(name="requestTimeout")
    def request_timeout(self) -> int:
        return pulumi.get(self, "request_timeout")

    @property
    @pulumi.getter(name="searchOrder")
    def search_order(self) -> str:
        return pulumi.get(self, "search_order")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderOpenstackCloudProviderRouteResult(dict):
    def __init__(__self__, *,
                 router_id: str):
        pulumi.set(__self__, "router_id", router_id)

    @property
    @pulumi.getter(name="routerId")
    def router_id(self) -> str:
        return pulumi.get(self, "router_id")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderResult(dict):
    def __init__(__self__, *,
                 disk: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult',
                 global_: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult',
                 network: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult',
                 virtual_centers: Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult'],
                 workspace: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult'):
        pulumi.set(__self__, "disk", disk)
        pulumi.set(__self__, "global_", global_)
        pulumi.set(__self__, "network", network)
        pulumi.set(__self__, "virtual_centers", virtual_centers)
        pulumi.set(__self__, "workspace", workspace)

    @property
    @pulumi.getter
    def disk(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult':
        return pulumi.get(self, "disk")

    @property
    @pulumi.getter(name="global")
    def global_(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult':
        return pulumi.get(self, "global_")

    @property
    @pulumi.getter
    def network(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult':
        return pulumi.get(self, "network")

    @property
    @pulumi.getter(name="virtualCenters")
    def virtual_centers(self) -> Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult']:
        return pulumi.get(self, "virtual_centers")

    @property
    @pulumi.getter
    def workspace(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult':
        return pulumi.get(self, "workspace")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderDiskResult(dict):
    def __init__(__self__, *,
                 scsi_controller_type: str):
        pulumi.set(__self__, "scsi_controller_type", scsi_controller_type)

    @property
    @pulumi.getter(name="scsiControllerType")
    def scsi_controller_type(self) -> str:
        return pulumi.get(self, "scsi_controller_type")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderGlobalResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 insecure_flag: bool,
                 password: str,
                 port: str,
                 soap_roundtrip_count: int,
                 user: str,
                 graceful_shutdown_timeout: Optional[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) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter(name="insecureFlag")
    def insecure_flag(self) -> bool:
        return pulumi.get(self, "insecure_flag")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="gracefulShutdownTimeout")
    def graceful_shutdown_timeout(self) -> Optional[str]:
        return pulumi.get(self, "graceful_shutdown_timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderNetworkResult(dict):
    def __init__(__self__, *,
                 public_network: str):
        pulumi.set(__self__, "public_network", public_network)

    @property
    @pulumi.getter(name="publicNetwork")
    def public_network(self) -> str:
        return pulumi.get(self, "public_network")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderVirtualCenterResult(dict):
    def __init__(__self__, *,
                 datacenters: str,
                 name: str,
                 password: str,
                 port: str,
                 soap_roundtrip_count: int,
                 user: str):
        """
        :param str name: The cluster template name (string)
        """
        pulumi.set(__self__, "datacenters", datacenters)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "soap_roundtrip_count", soap_roundtrip_count)
        pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def datacenters(self) -> str:
        return pulumi.get(self, "datacenters")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def port(self) -> str:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="soapRoundtripCount")
    def soap_roundtrip_count(self) -> int:
        return pulumi.get(self, "soap_roundtrip_count")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigCloudProviderVsphereCloudProviderWorkspaceResult(dict):
    def __init__(__self__, *,
                 datacenter: str,
                 default_datastore: str,
                 folder: str,
                 resourcepool_path: str,
                 server: str):
        pulumi.set(__self__, "datacenter", datacenter)
        pulumi.set(__self__, "default_datastore", default_datastore)
        pulumi.set(__self__, "folder", folder)
        pulumi.set(__self__, "resourcepool_path", resourcepool_path)
        pulumi.set(__self__, "server", server)

    @property
    @pulumi.getter
    def datacenter(self) -> str:
        return pulumi.get(self, "datacenter")

    @property
    @pulumi.getter(name="defaultDatastore")
    def default_datastore(self) -> str:
        return pulumi.get(self, "default_datastore")

    @property
    @pulumi.getter
    def folder(self) -> str:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter(name="resourcepoolPath")
    def resourcepool_path(self) -> str:
        return pulumi.get(self, "resourcepool_path")

    @property
    @pulumi.getter
    def server(self) -> str:
        return pulumi.get(self, "server")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsResult(dict):
    def __init__(__self__, *,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 reverse_cidrs: Sequence[str],
                 upstream_nameservers: Sequence[str],
                 linear_autoscaler_params: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult'] = None,
                 nodelocal: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult'] = None,
                 provider: Optional[str] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult'] = None):
        """
        :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, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="reverseCidrs")
    def reverse_cidrs(self) -> Sequence[str]:
        return pulumi.get(self, "reverse_cidrs")

    @property
    @pulumi.getter(name="upstreamNameservers")
    def upstream_nameservers(self) -> Sequence[str]:
        return pulumi.get(self, "upstream_nameservers")

    @property
    @pulumi.getter(name="linearAutoscalerParams")
    def linear_autoscaler_params(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsLinearAutoscalerParamsResult']:
        """
        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[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[float] = None,
                 max: Optional[int] = None,
                 min: Optional[int] = None,
                 nodes_per_replica: Optional[float] = None,
                 prevent_single_point_failure: Optional[bool] = None):
        if cores_per_replica is not None:
            pulumi.set(__self__, "cores_per_replica", cores_per_replica)
        if max is not None:
            pulumi.set(__self__, "max", max)
        if min is not None:
            pulumi.set(__self__, "min", min)
        if nodes_per_replica is not None:
            pulumi.set(__self__, "nodes_per_replica", nodes_per_replica)
        if prevent_single_point_failure is not None:
            pulumi.set(__self__, "prevent_single_point_failure", prevent_single_point_failure)

    @property
    @pulumi.getter(name="coresPerReplica")
    def cores_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "cores_per_replica")

    @property
    @pulumi.getter
    def max(self) -> Optional[int]:
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> Optional[int]:
        return pulumi.get(self, "min")

    @property
    @pulumi.getter(name="nodesPerReplica")
    def nodes_per_replica(self) -> Optional[float]:
        return pulumi.get(self, "nodes_per_replica")

    @property
    @pulumi.getter(name="preventSinglePointFailure")
    def prevent_single_point_failure(self) -> Optional[bool]:
        return pulumi.get(self, "prevent_single_point_failure")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsNodelocalResult(dict):
    def __init__(__self__, *,
                 ip_address: Optional[str] = None,
                 node_selector: Optional[Mapping[str, Any]] = None):
        """
        :param Mapping[str, Any] node_selector: Node selector key pair
        """
        if ip_address is not None:
            pulumi.set(__self__, "ip_address", ip_address)
        if node_selector is not None:
            pulumi.set(__self__, "node_selector", node_selector)

    @property
    @pulumi.getter(name="ipAddress")
    def ip_address(self) -> Optional[str]:
        return pulumi.get(self, "ip_address")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        """
        Node selector key pair
        """
        return pulumi.get(self, "node_selector")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsTolerationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigDnsUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressResult(dict):
    def __init__(__self__, *,
                 dns_policy: str,
                 extra_args: Mapping[str, Any],
                 http_port: int,
                 https_port: int,
                 network_mode: str,
                 node_selector: Mapping[str, Any],
                 options: Mapping[str, Any],
                 provider: str,
                 default_backend: Optional[bool] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult'] = None):
        """
        :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) -> str:
        return pulumi.get(self, "dns_policy")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="httpPort")
    def http_port(self) -> int:
        return pulumi.get(self, "http_port")

    @property
    @pulumi.getter(name="httpsPort")
    def https_port(self) -> int:
        return pulumi.get(self, "https_port")

    @property
    @pulumi.getter(name="networkMode")
    def network_mode(self) -> str:
        return pulumi.get(self, "network_mode")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Mapping[str, Any]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def options(self) -> Mapping[str, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter(name="defaultBackend")
    def default_backend(self) -> Optional[bool]:
        return pulumi.get(self, "default_backend")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressTolerationResult']]:
        """
        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: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigIngressUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_unavailable: Optional[int] = None):
        """
        :param 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[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 provider: str,
                 replicas: int,
                 node_selector: Optional[Mapping[str, Any]] = None,
                 tolerations: Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']] = None,
                 update_strategy: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult'] = None):
        """
        :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, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def provider(self) -> str:
        return pulumi.get(self, "provider")

    @property
    @pulumi.getter
    def replicas(self) -> int:
        return pulumi.get(self, "replicas")

    @property
    @pulumi.getter(name="nodeSelector")
    def node_selector(self) -> Optional[Mapping[str, Any]]:
        return pulumi.get(self, "node_selector")

    @property
    @pulumi.getter
    def tolerations(self) -> Optional[Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringTolerationResult']]:
        """
        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: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult'] = None,
                 strategy: Optional[str] = None):
        """
        :param 'GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateArgs' rolling_update: Rolling update for update strategy
        :param 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[str]:
        """
        Strategy
        """
        return pulumi.get(self, "strategy")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigMonitoringUpdateStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[int] = None,
                 max_unavailable: Optional[int] = None):
        """
        :param int max_surge: Rolling update max surge
        :param 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[int]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[int]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkResult(dict):
    def __init__(__self__, *,
                 options: Mapping[str, Any],
                 plugin: 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[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, Any]:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter
    def plugin(self) -> 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[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: str,
                 apic_hosts: Sequence[str],
                 apic_user_crt: str,
                 apic_user_key: str,
                 apic_user_name: str,
                 encap_type: str,
                 extern_dynamic: str,
                 extern_static: str,
                 kube_api_vlan: str,
                 l3out: str,
                 l3out_external_networks: Sequence[str],
                 mcast_range_end: str,
                 mcast_range_start: str,
                 node_subnet: str,
                 node_svc_subnet: str,
                 service_vlan: str,
                 system_id: str,
                 token: str,
                 vrf_name: str,
                 vrf_tenant: str,
                 apic_refresh_ticker_adjust: Optional[str] = None,
                 apic_refresh_time: Optional[str] = None,
                 apic_subscription_delay: Optional[str] = None,
                 capic: Optional[str] = None,
                 controller_log_level: Optional[str] = None,
                 disable_periodic_snat_global_info_sync: Optional[str] = None,
                 disable_wait_for_network: Optional[str] = None,
                 drop_log_enable: Optional[str] = None,
                 duration_wait_for_network: Optional[str] = None,
                 enable_endpoint_slice: Optional[str] = None,
                 ep_registry: Optional[str] = None,
                 gbp_pod_subnet: Optional[str] = None,
                 host_agent_log_level: Optional[str] = None,
                 image_pull_policy: Optional[str] = None,
                 image_pull_secret: Optional[str] = None,
                 infra_vlan: Optional[str] = None,
                 install_istio: Optional[str] = None,
                 istio_profile: Optional[str] = None,
                 kafka_brokers: Optional[Sequence[str]] = None,
                 kafka_client_crt: Optional[str] = None,
                 kafka_client_key: Optional[str] = None,
                 max_nodes_svc_graph: Optional[str] = None,
                 mtu_head_room: Optional[str] = None,
                 multus_disable: Optional[str] = None,
                 no_priority_class: Optional[str] = None,
                 node_pod_if_enable: Optional[str] = None,
                 opflex_client_ssl: Optional[str] = None,
                 opflex_device_delete_timeout: Optional[str] = None,
                 opflex_log_level: Optional[str] = None,
                 opflex_mode: Optional[str] = None,
                 opflex_server_port: Optional[str] = None,
                 overlay_vrf_name: Optional[str] = None,
                 ovs_memory_limit: Optional[str] = None,
                 pbr_tracking_non_snat: Optional[str] = None,
                 pod_subnet_chunk_size: Optional[str] = None,
                 run_gbp_container: Optional[str] = None,
                 run_opflex_server_container: Optional[str] = None,
                 service_monitor_interval: Optional[str] = None,
                 snat_contract_scope: Optional[str] = None,
                 snat_namespace: Optional[str] = None,
                 snat_port_range_end: Optional[str] = None,
                 snat_port_range_start: Optional[str] = None,
                 snat_ports_per_node: Optional[str] = None,
                 sriov_enable: Optional[str] = None,
                 subnet_domain_name: Optional[str] = None,
                 tenant: Optional[str] = None,
                 use_aci_anywhere_crd: Optional[str] = None,
                 use_aci_cni_priority_class: Optional[str] = None,
                 use_cluster_role: Optional[str] = None,
                 use_host_netns_volume: Optional[str] = None,
                 use_opflex_server_volume: Optional[str] = None,
                 use_privileged_container: Optional[str] = None,
                 vmm_controller: Optional[str] = None,
                 vmm_domain: Optional[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) -> str:
        return pulumi.get(self, "aep")

    @property
    @pulumi.getter(name="apicHosts")
    def apic_hosts(self) -> Sequence[str]:
        return pulumi.get(self, "apic_hosts")

    @property
    @pulumi.getter(name="apicUserCrt")
    def apic_user_crt(self) -> str:
        return pulumi.get(self, "apic_user_crt")

    @property
    @pulumi.getter(name="apicUserKey")
    def apic_user_key(self) -> str:
        return pulumi.get(self, "apic_user_key")

    @property
    @pulumi.getter(name="apicUserName")
    def apic_user_name(self) -> str:
        return pulumi.get(self, "apic_user_name")

    @property
    @pulumi.getter(name="encapType")
    def encap_type(self) -> str:
        return pulumi.get(self, "encap_type")

    @property
    @pulumi.getter(name="externDynamic")
    def extern_dynamic(self) -> str:
        return pulumi.get(self, "extern_dynamic")

    @property
    @pulumi.getter(name="externStatic")
    def extern_static(self) -> str:
        return pulumi.get(self, "extern_static")

    @property
    @pulumi.getter(name="kubeApiVlan")
    def kube_api_vlan(self) -> str:
        return pulumi.get(self, "kube_api_vlan")

    @property
    @pulumi.getter
    def l3out(self) -> str:
        return pulumi.get(self, "l3out")

    @property
    @pulumi.getter(name="l3outExternalNetworks")
    def l3out_external_networks(self) -> Sequence[str]:
        return pulumi.get(self, "l3out_external_networks")

    @property
    @pulumi.getter(name="mcastRangeEnd")
    def mcast_range_end(self) -> str:
        return pulumi.get(self, "mcast_range_end")

    @property
    @pulumi.getter(name="mcastRangeStart")
    def mcast_range_start(self) -> str:
        return pulumi.get(self, "mcast_range_start")

    @property
    @pulumi.getter(name="nodeSubnet")
    def node_subnet(self) -> str:
        return pulumi.get(self, "node_subnet")

    @property
    @pulumi.getter(name="nodeSvcSubnet")
    def node_svc_subnet(self) -> str:
        return pulumi.get(self, "node_svc_subnet")

    @property
    @pulumi.getter(name="serviceVlan")
    def service_vlan(self) -> str:
        return pulumi.get(self, "service_vlan")

    @property
    @pulumi.getter(name="systemId")
    def system_id(self) -> str:
        return pulumi.get(self, "system_id")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="vrfName")
    def vrf_name(self) -> str:
        return pulumi.get(self, "vrf_name")

    @property
    @pulumi.getter(name="vrfTenant")
    def vrf_tenant(self) -> str:
        return pulumi.get(self, "vrf_tenant")

    @property
    @pulumi.getter(name="apicRefreshTickerAdjust")
    def apic_refresh_ticker_adjust(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_ticker_adjust")

    @property
    @pulumi.getter(name="apicRefreshTime")
    def apic_refresh_time(self) -> Optional[str]:
        return pulumi.get(self, "apic_refresh_time")

    @property
    @pulumi.getter(name="apicSubscriptionDelay")
    def apic_subscription_delay(self) -> Optional[str]:
        return pulumi.get(self, "apic_subscription_delay")

    @property
    @pulumi.getter
    def capic(self) -> Optional[str]:
        return pulumi.get(self, "capic")

    @property
    @pulumi.getter(name="controllerLogLevel")
    def controller_log_level(self) -> Optional[str]:
        return pulumi.get(self, "controller_log_level")

    @property
    @pulumi.getter(name="disablePeriodicSnatGlobalInfoSync")
    def disable_periodic_snat_global_info_sync(self) -> Optional[str]:
        return pulumi.get(self, "disable_periodic_snat_global_info_sync")

    @property
    @pulumi.getter(name="disableWaitForNetwork")
    def disable_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "disable_wait_for_network")

    @property
    @pulumi.getter(name="dropLogEnable")
    def drop_log_enable(self) -> Optional[str]:
        return pulumi.get(self, "drop_log_enable")

    @property
    @pulumi.getter(name="durationWaitForNetwork")
    def duration_wait_for_network(self) -> Optional[str]:
        return pulumi.get(self, "duration_wait_for_network")

    @property
    @pulumi.getter(name="enableEndpointSlice")
    def enable_endpoint_slice(self) -> Optional[str]:
        return pulumi.get(self, "enable_endpoint_slice")

    @property
    @pulumi.getter(name="epRegistry")
    def ep_registry(self) -> Optional[str]:
        return pulumi.get(self, "ep_registry")

    @property
    @pulumi.getter(name="gbpPodSubnet")
    def gbp_pod_subnet(self) -> Optional[str]:
        return pulumi.get(self, "gbp_pod_subnet")

    @property
    @pulumi.getter(name="hostAgentLogLevel")
    def host_agent_log_level(self) -> Optional[str]:
        return pulumi.get(self, "host_agent_log_level")

    @property
    @pulumi.getter(name="imagePullPolicy")
    def image_pull_policy(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_policy")

    @property
    @pulumi.getter(name="imagePullSecret")
    def image_pull_secret(self) -> Optional[str]:
        return pulumi.get(self, "image_pull_secret")

    @property
    @pulumi.getter(name="infraVlan")
    def infra_vlan(self) -> Optional[str]:
        return pulumi.get(self, "infra_vlan")

    @property
    @pulumi.getter(name="installIstio")
    def install_istio(self) -> Optional[str]:
        return pulumi.get(self, "install_istio")

    @property
    @pulumi.getter(name="istioProfile")
    def istio_profile(self) -> Optional[str]:
        return pulumi.get(self, "istio_profile")

    @property
    @pulumi.getter(name="kafkaBrokers")
    def kafka_brokers(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "kafka_brokers")

    @property
    @pulumi.getter(name="kafkaClientCrt")
    def kafka_client_crt(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_crt")

    @property
    @pulumi.getter(name="kafkaClientKey")
    def kafka_client_key(self) -> Optional[str]:
        return pulumi.get(self, "kafka_client_key")

    @property
    @pulumi.getter(name="maxNodesSvcGraph")
    def max_nodes_svc_graph(self) -> Optional[str]:
        return pulumi.get(self, "max_nodes_svc_graph")

    @property
    @pulumi.getter(name="mtuHeadRoom")
    def mtu_head_room(self) -> Optional[str]:
        return pulumi.get(self, "mtu_head_room")

    @property
    @pulumi.getter(name="multusDisable")
    def multus_disable(self) -> Optional[str]:
        return pulumi.get(self, "multus_disable")

    @property
    @pulumi.getter(name="noPriorityClass")
    def no_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "no_priority_class")

    @property
    @pulumi.getter(name="nodePodIfEnable")
    def node_pod_if_enable(self) -> Optional[str]:
        return pulumi.get(self, "node_pod_if_enable")

    @property
    @pulumi.getter(name="opflexClientSsl")
    def opflex_client_ssl(self) -> Optional[str]:
        return pulumi.get(self, "opflex_client_ssl")

    @property
    @pulumi.getter(name="opflexDeviceDeleteTimeout")
    def opflex_device_delete_timeout(self) -> Optional[str]:
        return pulumi.get(self, "opflex_device_delete_timeout")

    @property
    @pulumi.getter(name="opflexLogLevel")
    def opflex_log_level(self) -> Optional[str]:
        return pulumi.get(self, "opflex_log_level")

    @property
    @pulumi.getter(name="opflexMode")
    def opflex_mode(self) -> Optional[str]:
        return pulumi.get(self, "opflex_mode")

    @property
    @pulumi.getter(name="opflexServerPort")
    def opflex_server_port(self) -> Optional[str]:
        return pulumi.get(self, "opflex_server_port")

    @property
    @pulumi.getter(name="overlayVrfName")
    def overlay_vrf_name(self) -> Optional[str]:
        return pulumi.get(self, "overlay_vrf_name")

    @property
    @pulumi.getter(name="ovsMemoryLimit")
    def ovs_memory_limit(self) -> Optional[str]:
        return pulumi.get(self, "ovs_memory_limit")

    @property
    @pulumi.getter(name="pbrTrackingNonSnat")
    def pbr_tracking_non_snat(self) -> Optional[str]:
        return pulumi.get(self, "pbr_tracking_non_snat")

    @property
    @pulumi.getter(name="podSubnetChunkSize")
    def pod_subnet_chunk_size(self) -> Optional[str]:
        return pulumi.get(self, "pod_subnet_chunk_size")

    @property
    @pulumi.getter(name="runGbpContainer")
    def run_gbp_container(self) -> Optional[str]:
        return pulumi.get(self, "run_gbp_container")

    @property
    @pulumi.getter(name="runOpflexServerContainer")
    def run_opflex_server_container(self) -> Optional[str]:
        return pulumi.get(self, "run_opflex_server_container")

    @property
    @pulumi.getter(name="serviceMonitorInterval")
    def service_monitor_interval(self) -> Optional[str]:
        return pulumi.get(self, "service_monitor_interval")

    @property
    @pulumi.getter(name="snatContractScope")
    def snat_contract_scope(self) -> Optional[str]:
        return pulumi.get(self, "snat_contract_scope")

    @property
    @pulumi.getter(name="snatNamespace")
    def snat_namespace(self) -> Optional[str]:
        return pulumi.get(self, "snat_namespace")

    @property
    @pulumi.getter(name="snatPortRangeEnd")
    def snat_port_range_end(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_end")

    @property
    @pulumi.getter(name="snatPortRangeStart")
    def snat_port_range_start(self) -> Optional[str]:
        return pulumi.get(self, "snat_port_range_start")

    @property
    @pulumi.getter(name="snatPortsPerNode")
    def snat_ports_per_node(self) -> Optional[str]:
        return pulumi.get(self, "snat_ports_per_node")

    @property
    @pulumi.getter(name="sriovEnable")
    def sriov_enable(self) -> Optional[str]:
        return pulumi.get(self, "sriov_enable")

    @property
    @pulumi.getter(name="subnetDomainName")
    def subnet_domain_name(self) -> Optional[str]:
        return pulumi.get(self, "subnet_domain_name")

    @property
    @pulumi.getter
    def tenant(self) -> Optional[str]:
        return pulumi.get(self, "tenant")

    @property
    @pulumi.getter(name="useAciAnywhereCrd")
    def use_aci_anywhere_crd(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_anywhere_crd")

    @property
    @pulumi.getter(name="useAciCniPriorityClass")
    def use_aci_cni_priority_class(self) -> Optional[str]:
        return pulumi.get(self, "use_aci_cni_priority_class")

    @property
    @pulumi.getter(name="useClusterRole")
    def use_cluster_role(self) -> Optional[str]:
        return pulumi.get(self, "use_cluster_role")

    @property
    @pulumi.getter(name="useHostNetnsVolume")
    def use_host_netns_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_host_netns_volume")

    @property
    @pulumi.getter(name="useOpflexServerVolume")
    def use_opflex_server_volume(self) -> Optional[str]:
        return pulumi.get(self, "use_opflex_server_volume")

    @property
    @pulumi.getter(name="usePrivilegedContainer")
    def use_privileged_container(self) -> Optional[str]:
        return pulumi.get(self, "use_privileged_container")

    @property
    @pulumi.getter(name="vmmController")
    def vmm_controller(self) -> Optional[str]:
        return pulumi.get(self, "vmm_controller")

    @property
    @pulumi.getter(name="vmmDomain")
    def vmm_domain(self) -> Optional[str]:
        return pulumi.get(self, "vmm_domain")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCalicoNetworkProviderResult(dict):
    def __init__(__self__, *,
                 cloud_provider: str):
        pulumi.set(__self__, "cloud_provider", cloud_provider)

    @property
    @pulumi.getter(name="cloudProvider")
    def cloud_provider(self) -> str:
        return pulumi.get(self, "cloud_provider")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkCanalNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkFlannelNetworkProviderResult(dict):
    def __init__(__self__, *,
                 iface: str):
        pulumi.set(__self__, "iface", iface)

    @property
    @pulumi.getter
    def iface(self) -> str:
        return pulumi.get(self, "iface")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkTolerationResult(dict):
    def __init__(__self__, *,
                 key: str,
                 seconds: int,
                 effect: Optional[str] = None,
                 operator: Optional[str] = None,
                 value: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "seconds", seconds)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)
        if operator is not None:
            pulumi.set(__self__, "operator", operator)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def seconds(self) -> int:
        return pulumi.get(self, "seconds")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def value(self) -> Optional[str]:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNetworkWeaveNetworkProviderResult(dict):
    def __init__(__self__, *,
                 password: str):
        pulumi.set(__self__, "password", password)

    @property
    @pulumi.getter
    def password(self) -> str:
        return pulumi.get(self, "password")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigNodeResult(dict):
    def __init__(__self__, *,
                 address: str,
                 docker_socket: str,
                 roles: Sequence[str],
                 ssh_key: str,
                 ssh_key_path: str,
                 user: str,
                 hostname_override: Optional[str] = None,
                 internal_address: Optional[str] = None,
                 labels: Optional[Mapping[str, Any]] = None,
                 node_id: Optional[str] = None,
                 port: Optional[str] = None,
                 ssh_agent_auth: Optional[bool] = None):
        """
        :param Mapping[str, Any] labels: (Computed) Labels for the cluster template (map)
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "docker_socket", docker_socket)
        pulumi.set(__self__, "roles", roles)
        pulumi.set(__self__, "ssh_key", ssh_key)
        pulumi.set(__self__, "ssh_key_path", ssh_key_path)
        pulumi.set(__self__, "user", user)
        if hostname_override is not None:
            pulumi.set(__self__, "hostname_override", hostname_override)
        if internal_address is not None:
            pulumi.set(__self__, "internal_address", internal_address)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if node_id is not None:
            pulumi.set(__self__, "node_id", node_id)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if ssh_agent_auth is not None:
            pulumi.set(__self__, "ssh_agent_auth", ssh_agent_auth)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter(name="dockerSocket")
    def docker_socket(self) -> str:
        return pulumi.get(self, "docker_socket")

    @property
    @pulumi.getter
    def roles(self) -> Sequence[str]:
        return pulumi.get(self, "roles")

    @property
    @pulumi.getter(name="sshKey")
    def ssh_key(self) -> str:
        return pulumi.get(self, "ssh_key")

    @property
    @pulumi.getter(name="sshKeyPath")
    def ssh_key_path(self) -> str:
        return pulumi.get(self, "ssh_key_path")

    @property
    @pulumi.getter
    def user(self) -> str:
        return pulumi.get(self, "user")

    @property
    @pulumi.getter(name="hostnameOverride")
    def hostname_override(self) -> Optional[str]:
        return pulumi.get(self, "hostname_override")

    @property
    @pulumi.getter(name="internalAddress")
    def internal_address(self) -> Optional[str]:
        return pulumi.get(self, "internal_address")

    @property
    @pulumi.getter
    def labels(self) -> Optional[Mapping[str, Any]]:
        """
        (Computed) Labels for the cluster template (map)
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="nodeId")
    def node_id(self) -> Optional[str]:
        return pulumi.get(self, "node_id")

    @property
    @pulumi.getter
    def port(self) -> Optional[str]:
        return pulumi.get(self, "port")

    @property
    @pulumi.getter(name="sshAgentAuth")
    def ssh_agent_auth(self) -> Optional[bool]:
        return pulumi.get(self, "ssh_agent_auth")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryResult(dict):
    def __init__(__self__, *,
                 url: str,
                 ecr_credential_plugin: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult'] = None,
                 is_default: Optional[bool] = None,
                 password: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :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) -> 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[bool]:
        return pulumi.get(self, "is_default")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        return pulumi.get(self, "user")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigPrivateRegistryEcrCredentialPluginResult(dict):
    def __init__(__self__, *,
                 aws_access_key_id: Optional[str] = None,
                 aws_secret_access_key: Optional[str] = None,
                 aws_session_token: Optional[str] = None):
        if aws_access_key_id is not None:
            pulumi.set(__self__, "aws_access_key_id", aws_access_key_id)
        if aws_secret_access_key is not None:
            pulumi.set(__self__, "aws_secret_access_key", aws_secret_access_key)
        if aws_session_token is not None:
            pulumi.set(__self__, "aws_session_token", aws_session_token)

    @property
    @pulumi.getter(name="awsAccessKeyId")
    def aws_access_key_id(self) -> Optional[str]:
        return pulumi.get(self, "aws_access_key_id")

    @property
    @pulumi.getter(name="awsSecretAccessKey")
    def aws_secret_access_key(self) -> Optional[str]:
        return pulumi.get(self, "aws_secret_access_key")

    @property
    @pulumi.getter(name="awsSessionToken")
    def aws_session_token(self) -> Optional[str]:
        return pulumi.get(self, "aws_session_token")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult',
                 kube_api: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult',
                 kube_controller: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult',
                 kubelet: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult',
                 kubeproxy: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult',
                 scheduler: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult'):
        pulumi.set(__self__, "etcd", etcd)
        pulumi.set(__self__, "kube_api", kube_api)
        pulumi.set(__self__, "kube_controller", kube_controller)
        pulumi.set(__self__, "kubelet", kubelet)
        pulumi.set(__self__, "kubeproxy", kubeproxy)
        pulumi.set(__self__, "scheduler", scheduler)

    @property
    @pulumi.getter
    def etcd(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult':
        return pulumi.get(self, "etcd")

    @property
    @pulumi.getter(name="kubeApi")
    def kube_api(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult':
        return pulumi.get(self, "kube_api")

    @property
    @pulumi.getter(name="kubeController")
    def kube_controller(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult':
        return pulumi.get(self, "kube_controller")

    @property
    @pulumi.getter
    def kubelet(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult':
        return pulumi.get(self, "kubelet")

    @property
    @pulumi.getter
    def kubeproxy(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult':
        return pulumi.get(self, "kubeproxy")

    @property
    @pulumi.getter
    def scheduler(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult':
        return pulumi.get(self, "scheduler")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdResult(dict):
    def __init__(__self__, *,
                 backup_config: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult',
                 ca_cert: str,
                 cert: str,
                 creation: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 key: str,
                 path: str,
                 retention: str,
                 snapshot: bool,
                 external_urls: Optional[Sequence[str]] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 gid: Optional[int] = None,
                 uid: Optional[int] = None):
        pulumi.set(__self__, "backup_config", backup_config)
        pulumi.set(__self__, "ca_cert", ca_cert)
        pulumi.set(__self__, "cert", cert)
        pulumi.set(__self__, "creation", creation)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "retention", retention)
        pulumi.set(__self__, "snapshot", snapshot)
        if external_urls is not None:
            pulumi.set(__self__, "external_urls", external_urls)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if gid is not None:
            pulumi.set(__self__, "gid", gid)
        if uid is not None:
            pulumi.set(__self__, "uid", uid)

    @property
    @pulumi.getter(name="backupConfig")
    def backup_config(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult':
        return pulumi.get(self, "backup_config")

    @property
    @pulumi.getter(name="caCert")
    def ca_cert(self) -> str:
        return pulumi.get(self, "ca_cert")

    @property
    @pulumi.getter
    def cert(self) -> str:
        return pulumi.get(self, "cert")

    @property
    @pulumi.getter
    def creation(self) -> str:
        return pulumi.get(self, "creation")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def retention(self) -> str:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter
    def snapshot(self) -> bool:
        return pulumi.get(self, "snapshot")

    @property
    @pulumi.getter(name="externalUrls")
    def external_urls(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "external_urls")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter
    def gid(self) -> Optional[int]:
        return pulumi.get(self, "gid")

    @property
    @pulumi.getter
    def uid(self) -> Optional[int]:
        return pulumi.get(self, "uid")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def timeout(self) -> int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesEtcdBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 service_node_port_range: str,
                 admission_configuration: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult'] = None,
                 always_pull_images: Optional[bool] = None,
                 audit_log: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult'] = None,
                 event_rate_limit: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult'] = None,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 pod_security_policy: Optional[bool] = None,
                 secrets_encryption_config: Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult'] = None):
        """
        :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 pod_security_policy is not None:
            pulumi.set(__self__, "pod_security_policy", pod_security_policy)
        if secrets_encryption_config is not None:
            pulumi.set(__self__, "secrets_encryption_config", secrets_encryption_config)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="serviceNodePortRange")
    def service_node_port_range(self) -> str:
        return pulumi.get(self, "service_node_port_range")

    @property
    @pulumi.getter(name="admissionConfiguration")
    def admission_configuration(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult']:
        """
        Cluster admission configuration
        """
        return pulumi.get(self, "admission_configuration")

    @property
    @pulumi.getter(name="alwaysPullImages")
    def always_pull_images(self) -> Optional[bool]:
        return pulumi.get(self, "always_pull_images")

    @property
    @pulumi.getter(name="auditLog")
    def audit_log(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult']:
        return pulumi.get(self, "audit_log")

    @property
    @pulumi.getter(name="eventRateLimit")
    def event_rate_limit(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult']:
        return pulumi.get(self, "event_rate_limit")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="podSecurityPolicy")
    def pod_security_policy(self) -> Optional[bool]:
        return pulumi.get(self, "pod_security_policy")

    @property
    @pulumi.getter(name="secretsEncryptionConfig")
    def secrets_encryption_config(self) -> Optional['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult']:
        return pulumi.get(self, "secrets_encryption_config")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationResult(dict):
    def __init__(__self__, *,
                 plugins: Sequence['outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult'],
                 api_version: Optional[str] = None,
                 kind: Optional[str] = None):
        """
        :param Sequence['GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginArgs'] plugins: Admission configuration plugins
        :param str api_version: Admission configuration ApiVersion
        :param 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[str]:
        """
        Admission configuration ApiVersion
        """
        return pulumi.get(self, "api_version")

    @property
    @pulumi.getter
    def kind(self) -> Optional[str]:
        """
        Admission configuration Kind
        """
        return pulumi.get(self, "kind")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAdmissionConfigurationPluginResult(dict):
    def __init__(__self__, *,
                 configuration: str,
                 name: str,
                 path: Optional[str] = None):
        """
        :param str configuration: Plugin configuration
        :param str name: The cluster template name (string)
        :param 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) -> str:
        """
        Plugin configuration
        """
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The cluster template name (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Plugin path
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogResult(dict):
    def __init__(__self__, *,
                 configuration: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult',
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult':
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiAuditLogConfigurationResult(dict):
    def __init__(__self__, *,
                 policy: str,
                 format: Optional[str] = None,
                 max_age: Optional[int] = None,
                 max_backup: Optional[int] = None,
                 max_size: Optional[int] = None,
                 path: Optional[str] = None):
        pulumi.set(__self__, "policy", policy)
        if format is not None:
            pulumi.set(__self__, "format", format)
        if max_age is not None:
            pulumi.set(__self__, "max_age", max_age)
        if max_backup is not None:
            pulumi.set(__self__, "max_backup", max_backup)
        if max_size is not None:
            pulumi.set(__self__, "max_size", max_size)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def policy(self) -> str:
        return pulumi.get(self, "policy")

    @property
    @pulumi.getter
    def format(self) -> Optional[str]:
        return pulumi.get(self, "format")

    @property
    @pulumi.getter(name="maxAge")
    def max_age(self) -> Optional[int]:
        return pulumi.get(self, "max_age")

    @property
    @pulumi.getter(name="maxBackup")
    def max_backup(self) -> Optional[int]:
        return pulumi.get(self, "max_backup")

    @property
    @pulumi.getter(name="maxSize")
    def max_size(self) -> Optional[int]:
        return pulumi.get(self, "max_size")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        return pulumi.get(self, "path")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiEventRateLimitResult(dict):
    def __init__(__self__, *,
                 configuration: str,
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "configuration", configuration)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter
    def configuration(self) -> str:
        return pulumi.get(self, "configuration")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeApiSecretsEncryptionConfigResult(dict):
    def __init__(__self__, *,
                 custom_config: str,
                 enabled: Optional[bool] = None):
        pulumi.set(__self__, "custom_config", custom_config)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="customConfig")
    def custom_config(self) -> str:
        return pulumi.get(self, "custom_config")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeControllerResult(dict):
    def __init__(__self__, *,
                 cluster_cidr: str,
                 extra_args: Mapping[str, Any],
                 image: str,
                 service_cluster_ip_range: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "cluster_cidr", cluster_cidr)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "service_cluster_ip_range", service_cluster_ip_range)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="clusterCidr")
    def cluster_cidr(self) -> str:
        return pulumi.get(self, "cluster_cidr")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="serviceClusterIpRange")
    def service_cluster_ip_range(self) -> str:
        return pulumi.get(self, "service_cluster_ip_range")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeletResult(dict):
    def __init__(__self__, *,
                 cluster_dns_server: str,
                 cluster_domain: str,
                 extra_args: Mapping[str, Any],
                 fail_swap_on: bool,
                 image: str,
                 infra_container_image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None,
                 generate_serving_certificate: Optional[bool] = None):
        pulumi.set(__self__, "cluster_dns_server", cluster_dns_server)
        pulumi.set(__self__, "cluster_domain", cluster_domain)
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "fail_swap_on", fail_swap_on)
        pulumi.set(__self__, "image", image)
        pulumi.set(__self__, "infra_container_image", infra_container_image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)
        if generate_serving_certificate is not None:
            pulumi.set(__self__, "generate_serving_certificate", generate_serving_certificate)

    @property
    @pulumi.getter(name="clusterDnsServer")
    def cluster_dns_server(self) -> str:
        return pulumi.get(self, "cluster_dns_server")

    @property
    @pulumi.getter(name="clusterDomain")
    def cluster_domain(self) -> str:
        return pulumi.get(self, "cluster_domain")

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter(name="failSwapOn")
    def fail_swap_on(self) -> bool:
        return pulumi.get(self, "fail_swap_on")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="infraContainerImage")
    def infra_container_image(self) -> str:
        return pulumi.get(self, "infra_container_image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")

    @property
    @pulumi.getter(name="generateServingCertificate")
    def generate_serving_certificate(self) -> Optional[bool]:
        return pulumi.get(self, "generate_serving_certificate")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesKubeproxyResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigServicesSchedulerResult(dict):
    def __init__(__self__, *,
                 extra_args: Mapping[str, Any],
                 image: str,
                 extra_binds: Optional[Sequence[str]] = None,
                 extra_envs: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "extra_args", extra_args)
        pulumi.set(__self__, "image", image)
        if extra_binds is not None:
            pulumi.set(__self__, "extra_binds", extra_binds)
        if extra_envs is not None:
            pulumi.set(__self__, "extra_envs", extra_envs)

    @property
    @pulumi.getter(name="extraArgs")
    def extra_args(self) -> Mapping[str, Any]:
        return pulumi.get(self, "extra_args")

    @property
    @pulumi.getter
    def image(self) -> str:
        return pulumi.get(self, "image")

    @property
    @pulumi.getter(name="extraBinds")
    def extra_binds(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_binds")

    @property
    @pulumi.getter(name="extraEnvs")
    def extra_envs(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "extra_envs")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 drain_input: 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult',
                 drain: Optional[bool] = None,
                 max_unavailable_controlplane: Optional[str] = None,
                 max_unavailable_worker: Optional[str] = None):
        pulumi.set(__self__, "drain_input", drain_input)
        if drain is not None:
            pulumi.set(__self__, "drain", drain)
        if max_unavailable_controlplane is not None:
            pulumi.set(__self__, "max_unavailable_controlplane", max_unavailable_controlplane)
        if max_unavailable_worker is not None:
            pulumi.set(__self__, "max_unavailable_worker", max_unavailable_worker)

    @property
    @pulumi.getter(name="drainInput")
    def drain_input(self) -> 'outputs.GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult':
        return pulumi.get(self, "drain_input")

    @property
    @pulumi.getter
    def drain(self) -> Optional[bool]:
        return pulumi.get(self, "drain")

    @property
    @pulumi.getter(name="maxUnavailableControlplane")
    def max_unavailable_controlplane(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_controlplane")

    @property
    @pulumi.getter(name="maxUnavailableWorker")
    def max_unavailable_worker(self) -> Optional[str]:
        return pulumi.get(self, "max_unavailable_worker")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionClusterConfigRkeConfigUpgradeStrategyDrainInputResult(dict):
    def __init__(__self__, *,
                 delete_local_data: Optional[bool] = None,
                 force: Optional[bool] = None,
                 grace_period: Optional[int] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 timeout: Optional[int] = None):
        if delete_local_data is not None:
            pulumi.set(__self__, "delete_local_data", delete_local_data)
        if force is not None:
            pulumi.set(__self__, "force", force)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if ignore_daemon_sets is not None:
            pulumi.set(__self__, "ignore_daemon_sets", ignore_daemon_sets)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="deleteLocalData")
    def delete_local_data(self) -> Optional[bool]:
        return pulumi.get(self, "delete_local_data")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="gracePeriod")
    def grace_period(self) -> Optional[int]:
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetClusterTemplateTemplateRevisionQuestionResult(dict):
    def __init__(__self__, *,
                 default: str,
                 variable: str,
                 required: Optional[bool] = None,
                 type: Optional[str] = None):
        """
        :param str default: Default variable value
        :param str variable: Variable name
        :param bool required: Required variable
        :param 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) -> str:
        """
        Default variable value
        """
        return pulumi.get(self, "default")

    @property
    @pulumi.getter
    def variable(self) -> str:
        """
        Variable name
        """
        return pulumi.get(self, "variable")

    @property
    @pulumi.getter
    def required(self) -> Optional[bool]:
        """
        Required variable
        """
        return pulumi.get(self, "required")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Variable type
        """
        return pulumi.get(self, "type")


@pulumi.output_type
class GetClusterV2AgentEnvVarResult(dict):
    def __init__(__self__, *,
                 name: str,
                 value: str):
        """
        :param str name: The name of the Cluster v2 (string)
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")


@pulumi.output_type
class GetClusterV2ClusterRegistrationTokenResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 cluster_id: str,
                 command: str,
                 id: str,
                 insecure_command: str,
                 insecure_node_command: str,
                 insecure_windows_node_command: str,
                 labels: Mapping[str, Any],
                 manifest_url: str,
                 name: str,
                 node_command: str,
                 token: str,
                 windows_node_command: str):
        """
        :param Mapping[str, Any] annotations: Annotations of the resource
        :param str id: (Computed) The ID of the resource (string)
        :param Mapping[str, Any] labels: Labels of the resource
        :param str name: The name of the Cluster v2 (string)
        """
        pulumi.set(__self__, "annotations", annotations)
        pulumi.set(__self__, "cluster_id", cluster_id)
        pulumi.set(__self__, "command", command)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "insecure_command", insecure_command)
        pulumi.set(__self__, "insecure_node_command", insecure_node_command)
        pulumi.set(__self__, "insecure_windows_node_command", insecure_windows_node_command)
        pulumi.set(__self__, "labels", labels)
        pulumi.set(__self__, "manifest_url", manifest_url)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "node_command", node_command)
        pulumi.set(__self__, "token", token)
        pulumi.set(__self__, "windows_node_command", windows_node_command)

    @property
    @pulumi.getter
    def annotations(self) -> Mapping[str, Any]:
        """
        Annotations of the resource
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter(name="clusterId")
    def cluster_id(self) -> str:
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter
    def command(self) -> str:
        return pulumi.get(self, "command")

    @property
    @pulumi.getter
    def id(self) -> str:
        """
        (Computed) The ID of the resource (string)
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter(name="insecureCommand")
    def insecure_command(self) -> str:
        return pulumi.get(self, "insecure_command")

    @property
    @pulumi.getter(name="insecureNodeCommand")
    def insecure_node_command(self) -> str:
        return pulumi.get(self, "insecure_node_command")

    @property
    @pulumi.getter(name="insecureWindowsNodeCommand")
    def insecure_windows_node_command(self) -> str:
        return pulumi.get(self, "insecure_windows_node_command")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        Labels of the resource
        """
        return pulumi.get(self, "labels")

    @property
    @pulumi.getter(name="manifestUrl")
    def manifest_url(self) -> str:
        return pulumi.get(self, "manifest_url")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="nodeCommand")
    def node_command(self) -> str:
        return pulumi.get(self, "node_command")

    @property
    @pulumi.getter
    def token(self) -> str:
        return pulumi.get(self, "token")

    @property
    @pulumi.getter(name="windowsNodeCommand")
    def windows_node_command(self) -> str:
        return pulumi.get(self, "windows_node_command")


@pulumi.output_type
class GetClusterV2RkeConfigResult(dict):
    def __init__(__self__, *,
                 etcd: 'outputs.GetClusterV2RkeConfigEtcdResult',
                 machine_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[str] = None,
                 chart_values: Optional[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[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 str additional_manifest: Cluster V2 additional manifest
        :param 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 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[str]:
        """
        Cluster V2 additional manifest
        """
        return pulumi.get(self, "additional_manifest")

    @property
    @pulumi.getter(name="chartValues")
    def chart_values(self) -> Optional[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")
    def local_auth_endpoint(self) -> Optional['outputs.GetClusterV2RkeConfigLocalAuthEndpointResult']:
        """
        Cluster V2 local auth endpoint
        """
        warnings.warn("""Use rancher2_cluster_v2.local_auth_endpoint instead""", DeprecationWarning)
        pulumi.log.warn("""local_auth_endpoint is deprecated: Use rancher2_cluster_v2.local_auth_endpoint instead""")

        return pulumi.get(self, "local_auth_endpoint")

    @property
    @pulumi.getter(name="machineGlobalConfig")
    def machine_global_config(self) -> Optional[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[bool] = None,
                 s3_config: Optional['outputs.GetClusterV2RkeConfigEtcdS3ConfigResult'] = None,
                 snapshot_retention: Optional[int] = None,
                 snapshot_schedule_cron: Optional[str] = None):
        """
        :param bool disable_snapshots: Disable ETCD snapshots
        :param 'GetClusterV2RkeConfigEtcdS3ConfigArgs' s3_config: ETCD snapshot S3 config
        :param int snapshot_retention: ETCD snapshot retention
        :param 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[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[int]:
        """
        ETCD snapshot retention
        """
        return pulumi.get(self, "snapshot_retention")

    @property
    @pulumi.getter(name="snapshotScheduleCron")
    def snapshot_schedule_cron(self) -> Optional[str]:
        """
        ETCD snapshot schedule cron (e.g `"0 */5 * * *"`)
        """
        return pulumi.get(self, "snapshot_schedule_cron")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdS3ConfigResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 endpoint: str,
                 cloud_credential_name: Optional[str] = None,
                 endpoint_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 skip_ssl_verify: Optional[bool] = None):
        """
        :param str bucket: ETCD snapshot S3 bucket
        :param str endpoint: ETCD snapshot S3 endpoint
        :param str cloud_credential_name: ETCD snapshot S3 cloud credential name
        :param str endpoint_ca: ETCD snapshot S3 endpoint CA
        :param str folder: ETCD snapshot S3 folder
        :param str region: ETCD snapshot S3 region
        :param 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) -> str:
        """
        ETCD snapshot S3 bucket
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        """
        ETCD snapshot S3 endpoint
        """
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="cloudCredentialName")
    def cloud_credential_name(self) -> Optional[str]:
        """
        ETCD snapshot S3 cloud credential name
        """
        return pulumi.get(self, "cloud_credential_name")

    @property
    @pulumi.getter(name="endpointCa")
    def endpoint_ca(self) -> Optional[str]:
        """
        ETCD snapshot S3 endpoint CA
        """
        return pulumi.get(self, "endpoint_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        """
        ETCD snapshot S3 folder
        """
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        """
        ETCD snapshot S3 region
        """
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="skipSslVerify")
    def skip_ssl_verify(self) -> Optional[bool]:
        """
        Disable ETCD skip ssl verify
        """
        return pulumi.get(self, "skip_ssl_verify")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdSnapshotCreateResult(dict):
    def __init__(__self__, *,
                 generation: int):
        """
        :param int generation: ETCD generation to initiate a snapshot
        """
        pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def generation(self) -> int:
        """
        ETCD generation to initiate a snapshot
        """
        return pulumi.get(self, "generation")


@pulumi.output_type
class GetClusterV2RkeConfigEtcdSnapshotRestoreResult(dict):
    def __init__(__self__, *,
                 generation: int,
                 name: str,
                 restore_rke_config: Optional[str] = None):
        """
        :param int generation: ETCD snapshot desired generation
        :param str name: The name of the Cluster v2 (string)
        :param 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) -> int:
        """
        ETCD snapshot desired generation
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="restoreRkeConfig")
    def restore_rke_config(self) -> Optional[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[str] = None,
                 enabled: Optional[bool] = None,
                 fqdn: Optional[str] = None):
        if ca_certs is not None:
            pulumi.set(__self__, "ca_certs", ca_certs)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if fqdn is not None:
            pulumi.set(__self__, "fqdn", fqdn)

    @property
    @pulumi.getter(name="caCerts")
    def ca_certs(self) -> Optional[str]:
        return pulumi.get(self, "ca_certs")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def fqdn(self) -> Optional[str]:
        return pulumi.get(self, "fqdn")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolResult(dict):
    def __init__(__self__, *,
                 annotations: Mapping[str, Any],
                 labels: Mapping[str, Any],
                 machine_config: 'outputs.GetClusterV2RkeConfigMachinePoolMachineConfigResult',
                 machine_labels: Mapping[str, Any],
                 name: str,
                 cloud_credential_secret_name: Optional[str] = None,
                 control_plane_role: Optional[bool] = None,
                 drain_before_delete: Optional[bool] = None,
                 etcd_role: Optional[bool] = None,
                 hostname_length_limit: Optional[int] = None,
                 max_unhealthy: Optional[str] = None,
                 node_drain_timeout: Optional[int] = None,
                 node_startup_timeout_seconds: Optional[int] = None,
                 paused: Optional[bool] = None,
                 quantity: Optional[int] = None,
                 rolling_update: Optional['outputs.GetClusterV2RkeConfigMachinePoolRollingUpdateResult'] = None,
                 taints: Optional[Sequence['outputs.GetClusterV2RkeConfigMachinePoolTaintResult']] = None,
                 unhealthy_node_timeout_seconds: Optional[int] = None,
                 unhealthy_range: Optional[str] = None,
                 worker_role: Optional[bool] = None):
        """
        :param Mapping[str, Any] annotations: Annotations of the resource
        :param Mapping[str, Any] labels: Labels of the resource
        :param 'GetClusterV2RkeConfigMachinePoolMachineConfigArgs' machine_config: Machine config data
        :param Mapping[str, Any] machine_labels: Labels of the machine
        :param str name: The name of the Cluster v2 (string)
        :param str cloud_credential_secret_name: (Computed) Cluster V2 cloud credential secret name (string)
        :param bool control_plane_role: Machine pool control plane role
        :param bool drain_before_delete: Machine pool drain before delete
        :param bool etcd_role: Machine pool etcd role
        :param int hostname_length_limit: maximum length for autogenerated hostname
        :param str max_unhealthy: max unhealthy nodes for automated replacement to be allowed
        :param int node_drain_timeout: seconds to wait for machine pool drain to complete before machine deletion
        :param int node_startup_timeout_seconds: seconds a new node has to become active before it is replaced
        :param bool paused: Machine pool paused
        :param int quantity: Machine pool quantity
        :param 'GetClusterV2RkeConfigMachinePoolRollingUpdateArgs' rolling_update: Machine pool rolling update
        :param Sequence['GetClusterV2RkeConfigMachinePoolTaintArgs'] taints: Machine pool taints
        :param int unhealthy_node_timeout_seconds: seconds an unhealthy node has to become active before it is replaced
        :param str unhealthy_range: range of unhealthy nodes for automated replacement to be allowed
        :param 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, Any]:
        """
        Annotations of the resource
        """
        return pulumi.get(self, "annotations")

    @property
    @pulumi.getter
    def labels(self) -> Mapping[str, Any]:
        """
        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, Any]:
        """
        Labels of the machine
        """
        return pulumi.get(self, "machine_labels")

    @property
    @pulumi.getter
    def name(self) -> 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[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[bool]:
        """
        Machine pool control plane role
        """
        return pulumi.get(self, "control_plane_role")

    @property
    @pulumi.getter(name="drainBeforeDelete")
    def drain_before_delete(self) -> Optional[bool]:
        """
        Machine pool drain before delete
        """
        return pulumi.get(self, "drain_before_delete")

    @property
    @pulumi.getter(name="etcdRole")
    def etcd_role(self) -> Optional[bool]:
        """
        Machine pool etcd role
        """
        return pulumi.get(self, "etcd_role")

    @property
    @pulumi.getter(name="hostnameLengthLimit")
    def hostname_length_limit(self) -> Optional[int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")

    @property
    @pulumi.getter(name="maxUnhealthy")
    def max_unhealthy(self) -> Optional[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[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[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[bool]:
        """
        Machine pool paused
        """
        return pulumi.get(self, "paused")

    @property
    @pulumi.getter
    def quantity(self) -> Optional[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[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[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[bool]:
        """
        Machine pool worker role
        """
        return pulumi.get(self, "worker_role")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolDefaultResult(dict):
    def __init__(__self__, *,
                 hostname_length_limit: Optional[int] = None):
        """
        :param 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[int]:
        """
        maximum length for autogenerated hostname
        """
        return pulumi.get(self, "hostname_length_limit")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolMachineConfigResult(dict):
    def __init__(__self__, *,
                 kind: str,
                 name: str,
                 api_version: Optional[str] = None):
        """
        :param str kind: Machine config kind
        :param str name: The name of the Cluster v2 (string)
        :param 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) -> str:
        """
        Machine config kind
        """
        return pulumi.get(self, "kind")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="apiVersion")
    def api_version(self) -> Optional[str]:
        """
        Machine config API version
        """
        return pulumi.get(self, "api_version")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolRollingUpdateResult(dict):
    def __init__(__self__, *,
                 max_surge: Optional[str] = None,
                 max_unavailable: Optional[str] = None):
        """
        :param str max_surge: Rolling update max surge
        :param 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[str]:
        """
        Rolling update max surge
        """
        return pulumi.get(self, "max_surge")

    @property
    @pulumi.getter(name="maxUnavailable")
    def max_unavailable(self) -> Optional[str]:
        """
        Rolling update max unavailable
        """
        return pulumi.get(self, "max_unavailable")


@pulumi.output_type
class GetClusterV2RkeConfigMachinePoolTaintResult(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str,
                 effect: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigResult(dict):
    def __init__(__self__, *,
                 config: Optional[str] = None,
                 machine_label_selector: Optional['outputs.GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorResult'] = None):
        """
        :param 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[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, Any]] = None):
        """
        :param Sequence['GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, Any] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[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, Any]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorConfigMachineLabelSelectorMatchExpressionResult(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: Label selector requirement key
        :param str operator: Label selector operator
        :param Sequence[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[str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[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: str,
                 default_permissions: Optional[str] = None,
                 items: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceConfigmapItemResult']] = None):
        """
        :param str name: The name of the Cluster v2 (string)
        :param 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) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[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: str,
                 path: str,
                 dynamic: Optional[bool] = None,
                 hash: Optional[str] = None,
                 permissions: Optional[str] = None):
        """
        :param str key: The key of the item(file) to retrieve
        :param str path: The path to put the file in the target node
        :param bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param 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) -> str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[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[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[str]:
        """
        The numeric representation of the file permissions
        """
        return pulumi.get(self, "permissions")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretResult(dict):
    def __init__(__self__, *,
                 name: str,
                 default_permissions: Optional[str] = None,
                 items: Optional[Sequence['outputs.GetClusterV2RkeConfigMachineSelectorFileFileSourceSecretItemResult']] = None):
        """
        :param str name: The name of the Cluster v2 (string)
        :param 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) -> str:
        """
        The name of the Cluster v2 (string)
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="defaultPermissions")
    def default_permissions(self) -> Optional[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: str,
                 path: str,
                 dynamic: Optional[bool] = None,
                 hash: Optional[str] = None,
                 permissions: Optional[str] = None):
        """
        :param str key: The key of the item(file) to retrieve
        :param str path: The path to put the file in the target node
        :param bool dynamic: If ture, the file is ignored when determining whether the node should be drained before updating the node plan (default: true).
        :param str hash: The base64 encoded value of the SHA256 checksum of the file's content
        :param 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) -> str:
        """
        The key of the item(file) to retrieve
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path to put the file in the target node
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter
    def dynamic(self) -> Optional[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[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[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, Any]] = None):
        """
        :param Sequence['GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionArgs'] match_expressions: Label selector match expressions
        :param Mapping[str, Any] match_labels: Label selector match labels
        """
        if match_expressions is not None:
            pulumi.set(__self__, "match_expressions", match_expressions)
        if match_labels is not None:
            pulumi.set(__self__, "match_labels", match_labels)

    @property
    @pulumi.getter(name="matchExpressions")
    def match_expressions(self) -> Optional[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, Any]]:
        """
        Label selector match labels
        """
        return pulumi.get(self, "match_labels")


@pulumi.output_type
class GetClusterV2RkeConfigMachineSelectorFileMachineLabelSelectorMatchExpressionResult(dict):
    def __init__(__self__, *,
                 key: Optional[str] = None,
                 operator: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        """
        :param str key: Label selector requirement key
        :param str operator: Label selector operator
        :param Sequence[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[str]:
        """
        Label selector requirement key
        """
        return pulumi.get(self, "key")

    @property
    @pulumi.getter
    def operator(self) -> Optional[str]:
        """
        Label selector operator
        """
        return pulumi.get(self, "operator")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[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: str,
                 auth_config_secret_name: Optional[str] = None,
                 ca_bundle: Optional[str] = None,
                 insecure: Optional[bool] = None,
                 tls_secret_name: Optional[str] = None):
        """
        :param str hostname: Registry hostname
        :param str auth_config_secret_name: Registry auth config secret name
        :param str ca_bundle: Registry CA bundle
        :param bool insecure: Registry insecure connectivity
        :param 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) -> str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter(name="authConfigSecretName")
    def auth_config_secret_name(self) -> Optional[str]:
        """
        Registry auth config secret name
        """
        return pulumi.get(self, "auth_config_secret_name")

    @property
    @pulumi.getter(name="caBundle")
    def ca_bundle(self) -> Optional[str]:
        """
        Registry CA bundle
        """
        return pulumi.get(self, "ca_bundle")

    @property
    @pulumi.getter
    def insecure(self) -> Optional[bool]:
        """
        Registry insecure connectivity
        """
        return pulumi.get(self, "insecure")

    @property
    @pulumi.getter(name="tlsSecretName")
    def tls_secret_name(self) -> Optional[str]:
        """
        Registry TLS secret name. TLS is a pair of Cert/Key
        """
        return pulumi.get(self, "tls_secret_name")


@pulumi.output_type
class GetClusterV2RkeConfigRegistriesMirrorResult(dict):
    def __init__(__self__, *,
                 hostname: str,
                 endpoints: Optional[Sequence[str]] = None,
                 rewrites: Optional[Mapping[str, Any]] = None):
        """
        :param str hostname: Registry hostname
        :param Sequence[str] endpoints: Registry mirror endpoints
        :param Mapping[str, Any] rewrites: Registry mirror rewrites
        """
        pulumi.set(__self__, "hostname", hostname)
        if endpoints is not None:
            pulumi.set(__self__, "endpoints", endpoints)
        if rewrites is not None:
            pulumi.set(__self__, "rewrites", rewrites)

    @property
    @pulumi.getter
    def hostname(self) -> str:
        """
        Registry hostname
        """
        return pulumi.get(self, "hostname")

    @property
    @pulumi.getter
    def endpoints(self) -> Optional[Sequence[str]]:
        """
        Registry mirror endpoints
        """
        return pulumi.get(self, "endpoints")

    @property
    @pulumi.getter
    def rewrites(self) -> Optional[Mapping[str, Any]]:
        """
        Registry mirror rewrites
        """
        return pulumi.get(self, "rewrites")


@pulumi.output_type
class GetClusterV2RkeConfigRotateCertificatesResult(dict):
    def __init__(__self__, *,
                 generation: int,
                 services: Optional[Sequence[str]] = None):
        """
        :param int generation: Desired certificate rotation generation.
        :param Sequence[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) -> int:
        """
        Desired certificate rotation generation.
        """
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def services(self) -> Optional[Sequence[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[str] = None,
                 control_plane_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyControlPlaneDrainOptionsResult'] = None,
                 worker_concurrency: Optional[str] = None,
                 worker_drain_options: Optional['outputs.GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult'] = None):
        """
        :param 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 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[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[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: int,
                 skip_wait_for_delete_timeout_seconds: int,
                 timeout: int,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None):
        """
        :param int grace_period: Drain options grace period
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param int timeout: Drain options timeout
        :param bool delete_empty_dir_data: Drain options delete empty dir data
        :param bool disable_eviction: Drain options disable eviction
        :param bool enabled: Drain options enabled?
        :param bool force: Drain options force
        :param bool ignore_daemon_sets: Drain options ignore daemon sets
        :param 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) -> int:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> 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) -> int:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[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[bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")


@pulumi.output_type
class GetClusterV2RkeConfigUpgradeStrategyWorkerDrainOptionsResult(dict):
    def __init__(__self__, *,
                 grace_period: int,
                 skip_wait_for_delete_timeout_seconds: int,
                 timeout: int,
                 delete_empty_dir_data: Optional[bool] = None,
                 disable_eviction: Optional[bool] = None,
                 enabled: Optional[bool] = None,
                 force: Optional[bool] = None,
                 ignore_daemon_sets: Optional[bool] = None,
                 ignore_errors: Optional[bool] = None):
        """
        :param int grace_period: Drain options grace period
        :param int skip_wait_for_delete_timeout_seconds: Drain options skip wait for delete timeout seconds
        :param int timeout: Drain options timeout
        :param bool delete_empty_dir_data: Drain options delete empty dir data
        :param bool disable_eviction: Drain options disable eviction
        :param bool enabled: Drain options enabled?
        :param bool force: Drain options force
        :param bool ignore_daemon_sets: Drain options ignore daemon sets
        :param 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) -> int:
        """
        Drain options grace period
        """
        return pulumi.get(self, "grace_period")

    @property
    @pulumi.getter(name="skipWaitForDeleteTimeoutSeconds")
    def skip_wait_for_delete_timeout_seconds(self) -> 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) -> int:
        """
        Drain options timeout
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter(name="deleteEmptyDirData")
    def delete_empty_dir_data(self) -> Optional[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[bool]:
        """
        Drain options disable eviction
        """
        return pulumi.get(self, "disable_eviction")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        """
        Drain options enabled?
        """
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter
    def force(self) -> Optional[bool]:
        """
        Drain options force
        """
        return pulumi.get(self, "force")

    @property
    @pulumi.getter(name="ignoreDaemonSets")
    def ignore_daemon_sets(self) -> Optional[bool]:
        """
        Drain options ignore daemon sets
        """
        return pulumi.get(self, "ignore_daemon_sets")

    @property
    @pulumi.getter(name="ignoreErrors")
    def ignore_errors(self) -> Optional[bool]:
        """
        Drain options ignore errors
        """
        return pulumi.get(self, "ignore_errors")


@pulumi.output_type
class GetEtcdBackupBackupConfigResult(dict):
    def __init__(__self__, *,
                 timeout: int,
                 enabled: Optional[bool] = None,
                 interval_hours: Optional[int] = None,
                 retention: Optional[int] = None,
                 s3_backup_config: Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult'] = None,
                 safe_timestamp: Optional[bool] = None):
        pulumi.set(__self__, "timeout", timeout)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if interval_hours is not None:
            pulumi.set(__self__, "interval_hours", interval_hours)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)
        if s3_backup_config is not None:
            pulumi.set(__self__, "s3_backup_config", s3_backup_config)
        if safe_timestamp is not None:
            pulumi.set(__self__, "safe_timestamp", safe_timestamp)

    @property
    @pulumi.getter
    def timeout(self) -> int:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def enabled(self) -> Optional[bool]:
        return pulumi.get(self, "enabled")

    @property
    @pulumi.getter(name="intervalHours")
    def interval_hours(self) -> Optional[int]:
        return pulumi.get(self, "interval_hours")

    @property
    @pulumi.getter
    def retention(self) -> Optional[int]:
        return pulumi.get(self, "retention")

    @property
    @pulumi.getter(name="s3BackupConfig")
    def s3_backup_config(self) -> Optional['outputs.GetEtcdBackupBackupConfigS3BackupConfigResult']:
        return pulumi.get(self, "s3_backup_config")

    @property
    @pulumi.getter(name="safeTimestamp")
    def safe_timestamp(self) -> Optional[bool]:
        return pulumi.get(self, "safe_timestamp")


@pulumi.output_type
class GetEtcdBackupBackupConfigS3BackupConfigResult(dict):
    def __init__(__self__, *,
                 bucket_name: str,
                 endpoint: str,
                 access_key: Optional[str] = None,
                 custom_ca: Optional[str] = None,
                 folder: Optional[str] = None,
                 region: Optional[str] = None,
                 secret_key: Optional[str] = None):
        pulumi.set(__self__, "bucket_name", bucket_name)
        pulumi.set(__self__, "endpoint", endpoint)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if custom_ca is not None:
            pulumi.set(__self__, "custom_ca", custom_ca)
        if folder is not None:
            pulumi.set(__self__, "folder", folder)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="bucketName")
    def bucket_name(self) -> str:
        return pulumi.get(self, "bucket_name")

    @property
    @pulumi.getter
    def endpoint(self) -> str:
        return pulumi.get(self, "endpoint")

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[str]:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="customCa")
    def custom_ca(self) -> Optional[str]:
        return pulumi.get(self, "custom_ca")

    @property
    @pulumi.getter
    def folder(self) -> Optional[str]:
        return pulumi.get(self, "folder")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[str]:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetGlobalDnsProviderAlidnsConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> str:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        return pulumi.get(self, "secret_key")


@pulumi.output_type
class GetGlobalDnsProviderCloudflareConfigResult(dict):
    def __init__(__self__, *,
                 api_email: str,
                 api_key: str,
                 proxy_setting: Optional[bool] = None):
        pulumi.set(__self__, "api_email", api_email)
        pulumi.set(__self__, "api_key", api_key)
        if proxy_setting is not None:
            pulumi.set(__self__, "proxy_setting", proxy_setting)

    @property
    @pulumi.getter(name="apiEmail")
    def api_email(self) -> str:
        return pulumi.get(self, "api_email")

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> str:
        return pulumi.get(self, "api_key")

    @property
    @pulumi.getter(name="proxySetting")
    def proxy_setting(self) -> Optional[bool]:
        return pulumi.get(self, "proxy_setting")


@pulumi.output_type
class GetGlobalDnsProviderRoute53ConfigResult(dict):
    def __init__(__self__, *,
                 access_key: str,
                 secret_key: str,
                 credentials_path: Optional[str] = None,
                 region: Optional[str] = None,
                 role_arn: Optional[str] = None,
                 zone_type: Optional[str] = None):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "secret_key", secret_key)
        if credentials_path is not None:
            pulumi.set(__self__, "credentials_path", credentials_path)
        if region is not None:
            pulumi.set(__self__, "region", region)
        if role_arn is not None:
            pulumi.set(__self__, "role_arn", role_arn)
        if zone_type is not None:
            pulumi.set(__self__, "zone_type", zone_type)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> str:
        return pulumi.get(self, "access_key")

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> str:
        return pulumi.get(self, "secret_key")

    @property
    @pulumi.getter(name="credentialsPath")
    def credentials_path(self) -> Optional[str]:
        return pulumi.get(self, "credentials_path")

    @property
    @pulumi.getter
    def region(self) -> Optional[str]:
        return pulumi.get(self, "region")

    @property
    @pulumi.getter(name="roleArn")
    def role_arn(self) -> Optional[str]:
        return pulumi.get(self, "role_arn")

    @property
    @pulumi.getter(name="zoneType")
    def zone_type(self) -> Optional[str]:
        return pulumi.get(self, "zone_type")


@pulumi.output_type
class GetGlobalRoleRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups
        :param Sequence[str] non_resource_urls: Policy rule non resource urls
        :param Sequence[str] resource_names: Policy rule resource names
        :param Sequence[str] resources: Policy rule resources
        :param Sequence[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[str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


@pulumi.output_type
class GetMultiClusterAppAnswerResult(dict):
    def __init__(__self__, *,
                 cluster_id: str,
                 project_id: str,
                 values: Mapping[str, Any]):
        """
        :param str cluster_id: Cluster ID for answer
        :param str project_id: Project ID for answer
        :param Mapping[str, Any] 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) -> str:
        """
        Cluster ID for answer
        """
        return pulumi.get(self, "cluster_id")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        Project ID for answer
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def values(self) -> Mapping[str, Any]:
        """
        Key/values for answer
        """
        return pulumi.get(self, "values")


@pulumi.output_type
class GetMultiClusterAppMemberResult(dict):
    def __init__(__self__, *,
                 access_type: Optional[str] = None,
                 group_principal_id: Optional[str] = None,
                 user_principal_id: Optional[str] = None):
        """
        :param str access_type: Member access type: member, owner, read-only
        :param str group_principal_id: Member group principal id
        :param 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[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[str]:
        """
        Member group principal id
        """
        return pulumi.get(self, "group_principal_id")

    @property
    @pulumi.getter(name="userPrincipalId")
    def user_principal_id(self) -> Optional[str]:
        """
        Member user principal id
        """
        return pulumi.get(self, "user_principal_id")


@pulumi.output_type
class GetMultiClusterAppTargetResult(dict):
    def __init__(__self__, *,
                 app_id: str,
                 health_state: str,
                 project_id: str,
                 state: str):
        """
        :param str app_id: App ID for target
        :param str health_state: App health state for target
        :param str project_id: Project ID for target
        :param str state: App state for target
        """
        pulumi.set(__self__, "app_id", app_id)
        pulumi.set(__self__, "health_state", health_state)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter(name="appId")
    def app_id(self) -> str:
        """
        App ID for target
        """
        return pulumi.get(self, "app_id")

    @property
    @pulumi.getter(name="healthState")
    def health_state(self) -> str:
        """
        App health state for target
        """
        return pulumi.get(self, "health_state")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        """
        Project ID for target
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def state(self) -> str:
        """
        App state for target
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class GetMultiClusterAppUpgradeStrategyResult(dict):
    def __init__(__self__, *,
                 rolling_update: Optional['outputs.GetMultiClusterAppUpgradeStrategyRollingUpdateResult'] = None):
        """
        :param 'GetMultiClusterAppUpgradeStrategyRollingUpdateArgs' rolling_update: Rolling update for upgrade strategy
        """
        if rolling_update is not None:
            pulumi.set(__self__, "rolling_update", rolling_update)

    @property
    @pulumi.getter(name="rollingUpdate")
    def rolling_update(self) -> Optional['outputs.GetMultiClusterAppUpgradeStrategyRollingUpdateResult']:
        """
        Rolling update for upgrade strategy
        """
        return pulumi.get(self, "rolling_update")


@pulumi.output_type
class GetMultiClusterAppUpgradeStrategyRollingUpdateResult(dict):
    def __init__(__self__, *,
                 batch_size: Optional[int] = None,
                 interval: Optional[int] = None):
        """
        :param int batch_size: Rolling update batch size
        :param int interval: Rolling update interval
        """
        if batch_size is not None:
            pulumi.set(__self__, "batch_size", batch_size)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)

    @property
    @pulumi.getter(name="batchSize")
    def batch_size(self) -> Optional[int]:
        """
        Rolling update batch size
        """
        return pulumi.get(self, "batch_size")

    @property
    @pulumi.getter
    def interval(self) -> Optional[int]:
        """
        Rolling update interval
        """
        return pulumi.get(self, "interval")


@pulumi.output_type
class GetNamespaceContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class GetNamespaceResourceQuotaResult(dict):
    def __init__(__self__, *,
                 limit: 'outputs.GetNamespaceResourceQuotaLimitResult'):
        pulumi.set(__self__, "limit", limit)

    @property
    @pulumi.getter
    def limit(self) -> 'outputs.GetNamespaceResourceQuotaLimitResult':
        return pulumi.get(self, "limit")


@pulumi.output_type
class GetNamespaceResourceQuotaLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetNodePoolNodeTaintResult(dict):
    def __init__(__self__, *,
                 key: str,
                 time_added: str,
                 value: str,
                 effect: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "time_added", time_added)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> str:
        return pulumi.get(self, "time_added")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetNodeTemplateNodeTaintResult(dict):
    def __init__(__self__, *,
                 key: str,
                 time_added: str,
                 value: str,
                 effect: Optional[str] = None):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "time_added", time_added)
        pulumi.set(__self__, "value", value)
        if effect is not None:
            pulumi.set(__self__, "effect", effect)

    @property
    @pulumi.getter
    def key(self) -> str:
        return pulumi.get(self, "key")

    @property
    @pulumi.getter(name="timeAdded")
    def time_added(self) -> str:
        return pulumi.get(self, "time_added")

    @property
    @pulumi.getter
    def value(self) -> str:
        return pulumi.get(self, "value")

    @property
    @pulumi.getter
    def effect(self) -> Optional[str]:
        return pulumi.get(self, "effect")


@pulumi.output_type
class GetNotifierDingtalkConfigResult(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None,
                 secret: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: Dingtalk proxy URL
        :param str secret: Required for webhook with sign enabled
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if secret is not None:
            pulumi.set(__self__, "secret", secret)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Dingtalk proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter
    def secret(self) -> Optional[str]:
        """
        Required for webhook with sign enabled
        """
        return pulumi.get(self, "secret")


@pulumi.output_type
class GetNotifierMsteamsConfigResult(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: MS teams proxy URL
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        MS teams proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierPagerdutyConfigResult(dict):
    def __init__(__self__, *,
                 service_key: str,
                 proxy_url: Optional[str] = None):
        """
        :param str service_key: Pagerduty service key
        :param str proxy_url: Pagerduty proxy URL
        """
        pulumi.set(__self__, "service_key", service_key)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="serviceKey")
    def service_key(self) -> str:
        """
        Pagerduty service key
        """
        return pulumi.get(self, "service_key")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Pagerduty proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierSlackConfigResult(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str default_recipient: Slack default channel
        :param str url: Slack URL
        :param str proxy_url: Slack proxy URL
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Slack default channel
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Slack URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Slack proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierSmtpConfigResult(dict):
    def __init__(__self__, *,
                 default_recipient: str,
                 host: str,
                 port: int,
                 sender: str,
                 password: Optional[str] = None,
                 tls: Optional[bool] = None,
                 username: Optional[str] = None):
        """
        :param str default_recipient: SMTP default recipient address
        :param str host: SMTP host
        :param int port: SMTP port
        :param str sender: SMTP sender
        :param str password: SMTP password
        :param bool tls: SMTP TLS
        :param str username: SMTP username
        """
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "sender", sender)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if tls is not None:
            pulumi.set(__self__, "tls", tls)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        SMTP default recipient address
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def host(self) -> str:
        """
        SMTP host
        """
        return pulumi.get(self, "host")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        SMTP port
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def sender(self) -> str:
        """
        SMTP sender
        """
        return pulumi.get(self, "sender")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        """
        SMTP password
        """
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def tls(self) -> Optional[bool]:
        """
        SMTP TLS
        """
        return pulumi.get(self, "tls")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        """
        SMTP username
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class GetNotifierWebhookConfigResult(dict):
    def __init__(__self__, *,
                 url: str,
                 proxy_url: Optional[str] = None):
        """
        :param str url: Webhook URL
        :param str proxy_url: Webhook proxy URL
        """
        pulumi.set(__self__, "url", url)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)

    @property
    @pulumi.getter
    def url(self) -> str:
        """
        Webhook URL
        """
        return pulumi.get(self, "url")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Webhook proxy URL
        """
        return pulumi.get(self, "proxy_url")


@pulumi.output_type
class GetNotifierWechatConfigResult(dict):
    def __init__(__self__, *,
                 agent: str,
                 corp: str,
                 default_recipient: str,
                 secret: str,
                 proxy_url: Optional[str] = None,
                 recipient_type: Optional[str] = None):
        """
        :param str agent: Wechat application agent ID
        :param str corp: Wechat corporation ID
        :param str default_recipient: Wechat default channel
        :param str secret: Wechat application secret
        :param str proxy_url: Wechat proxy URL
        :param str recipient_type: Wechat recipient type
        """
        pulumi.set(__self__, "agent", agent)
        pulumi.set(__self__, "corp", corp)
        pulumi.set(__self__, "default_recipient", default_recipient)
        pulumi.set(__self__, "secret", secret)
        if proxy_url is not None:
            pulumi.set(__self__, "proxy_url", proxy_url)
        if recipient_type is not None:
            pulumi.set(__self__, "recipient_type", recipient_type)

    @property
    @pulumi.getter
    def agent(self) -> str:
        """
        Wechat application agent ID
        """
        return pulumi.get(self, "agent")

    @property
    @pulumi.getter
    def corp(self) -> str:
        """
        Wechat corporation ID
        """
        return pulumi.get(self, "corp")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> str:
        """
        Wechat default channel
        """
        return pulumi.get(self, "default_recipient")

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Wechat application secret
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter(name="proxyUrl")
    def proxy_url(self) -> Optional[str]:
        """
        Wechat proxy URL
        """
        return pulumi.get(self, "proxy_url")

    @property
    @pulumi.getter(name="recipientType")
    def recipient_type(self) -> Optional[str]:
        """
        Wechat recipient type
        """
        return pulumi.get(self, "recipient_type")


@pulumi.output_type
class GetPodSecurityAdmissionConfigurationTemplateDefaultsResult(dict):
    def __init__(__self__, *,
                 audit: Optional[str] = None,
                 audit_version: Optional[str] = None,
                 enforce: Optional[str] = None,
                 enforce_version: Optional[str] = None,
                 warn: Optional[str] = None,
                 warn_version: Optional[str] = None):
        """
        :param str audit: Pod Security Admission Configuration audit. This audits a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param str audit_version: Pod Security Admission Configuration audit version (default: latest)
        :param str enforce: Pod Security Admission Configuration enforce. This rejects a pod in violation of privileged, baseline, or restricted policy (default: privileged)
        :param str enforce_version: Pod Security Admission Configuration enforce version (default: latest)
        :param 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 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[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[str]:
        """
        Pod Security Admission Configuration audit version (default: latest)
        """
        return pulumi.get(self, "audit_version")

    @property
    @pulumi.getter
    def enforce(self) -> Optional[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[str]:
        """
        Pod Security Admission Configuration enforce version (default: latest)
        """
        return pulumi.get(self, "enforce_version")

    @property
    @pulumi.getter
    def warn(self) -> Optional[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[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[str]] = None,
                 runtime_classes: Optional[Sequence[str]] = None,
                 usernames: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] namespaces: Pod Security Admission Configuration namespace exemptions
        :param Sequence[str] runtime_classes: Pod Security Admission Configuration runtime class exemptions
        :param Sequence[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[str]]:
        """
        Pod Security Admission Configuration namespace exemptions
        """
        return pulumi.get(self, "namespaces")

    @property
    @pulumi.getter(name="runtimeClasses")
    def runtime_classes(self) -> Optional[Sequence[str]]:
        """
        Pod Security Admission Configuration runtime class exemptions
        """
        return pulumi.get(self, "runtime_classes")

    @property
    @pulumi.getter
    def usernames(self) -> Optional[Sequence[str]]:
        """
        Pod Security Admission Configuration username exemptions
        """
        return pulumi.get(self, "usernames")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedCsiDriverResult(dict):
    def __init__(__self__, *,
                 name: str):
        """
        :param str name: The name of the PodSecurityPolicyTemplate (string)
        """
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the PodSecurityPolicyTemplate (string)
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedFlexVolumeResult(dict):
    def __init__(__self__, *,
                 driver: str):
        """
        :param str driver: driver is the name of the Flexvolume driver.
        """
        pulumi.set(__self__, "driver", driver)

    @property
    @pulumi.getter
    def driver(self) -> str:
        """
        driver is the name of the Flexvolume driver.
        """
        return pulumi.get(self, "driver")


@pulumi.output_type
class GetPodSecurityPolicyTemplateAllowedHostPathResult(dict):
    def __init__(__self__, *,
                 path_prefix: str,
                 read_only: Optional[bool] = None):
        """
        :param str path_prefix: pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        :param bool read_only: when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        pulumi.set(__self__, "path_prefix", path_prefix)
        if read_only is not None:
            pulumi.set(__self__, "read_only", read_only)

    @property
    @pulumi.getter(name="pathPrefix")
    def path_prefix(self) -> str:
        """
        pathPrefix is the path prefix that the host volume must match. It does not support `*`. Trailing slashes are trimmed when validating the path prefix with a host path.
        """
        return pulumi.get(self, "path_prefix")

    @property
    @pulumi.getter(name="readOnly")
    def read_only(self) -> Optional[bool]:
        """
        when set to true, will allow host volumes matching the pathPrefix only if all volume mounts are readOnly.
        """
        return pulumi.get(self, "read_only")


@pulumi.output_type
class GetPodSecurityPolicyTemplateFsGroupResult(dict):
    def __init__(__self__, *,
                 ranges: Sequence['outputs.GetPodSecurityPolicyTemplateFsGroupRangeResult'],
                 rule: Optional[str] = None):
        """
        :param Sequence['GetPodSecurityPolicyTemplateFsGroupRangeArgs'] ranges: ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['outputs.GetPodSecurityPolicyTemplateFsGroupRangeResult']:
        """
        ranges are the allowed ranges of fs groups.  If you would like to force a single fs group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what FSGroup is used in the SecurityContext.
        """
        return pulumi.get(self, "rule")


@pulumi.output_type
class GetPodSecurityPolicyTemplateFsGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateHostPortResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsGroupRangeResult']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        :param Sequence['GetPodSecurityPolicyTemplateRunAsGroupRangeArgs'] ranges: ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsGroup values that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsGroupRangeResult']]:
        """
        ranges are the allowed ranges of gids that may be used. If you would like to force a single gid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 ranges: Optional[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsUserRangeResult']] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        :param Sequence['GetPodSecurityPolicyTemplateRunAsUserRangeArgs'] ranges: ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        pulumi.set(__self__, "rule", rule)
        if ranges is not None:
            pulumi.set(__self__, "ranges", ranges)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable RunAsUser values that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter
    def ranges(self) -> Optional[Sequence['outputs.GetPodSecurityPolicyTemplateRunAsUserRangeResult']]:
        """
        ranges are the allowed ranges of uids that may be used. If you would like to force a single uid then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRunAsUserRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class GetPodSecurityPolicyTemplateRuntimeClassResult(dict):
    def __init__(__self__, *,
                 allowed_runtime_class_names: Sequence[str],
                 default_runtime_class_name: Optional[str] = None):
        """
        :param Sequence[str] allowed_runtime_class_names: allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        :param str default_runtime_class_name: defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        pulumi.set(__self__, "allowed_runtime_class_names", allowed_runtime_class_names)
        if default_runtime_class_name is not None:
            pulumi.set(__self__, "default_runtime_class_name", default_runtime_class_name)

    @property
    @pulumi.getter(name="allowedRuntimeClassNames")
    def allowed_runtime_class_names(self) -> Sequence[str]:
        """
        allowedRuntimeClassNames is a whitelist of RuntimeClass names that may be specified on a pod. A value of "*" means that any RuntimeClass name is allowed, and must be the only item in the list. An empty list requires the RuntimeClassName field to be unset.
        """
        return pulumi.get(self, "allowed_runtime_class_names")

    @property
    @pulumi.getter(name="defaultRuntimeClassName")
    def default_runtime_class_name(self) -> Optional[str]:
        """
        defaultRuntimeClassName is the default RuntimeClassName to set on the pod. The default MUST be allowed by the allowedRuntimeClassNames list. A value of nil does not mutate the Pod.
        """
        return pulumi.get(self, "default_runtime_class_name")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSeLinuxResult(dict):
    def __init__(__self__, *,
                 rule: str,
                 se_linux_option: Optional['outputs.GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult'] = None):
        """
        :param str rule: rule is the strategy that will dictate the allowable labels that may be set.
        :param 'GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionArgs' se_linux_option: seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        pulumi.set(__self__, "rule", rule)
        if se_linux_option is not None:
            pulumi.set(__self__, "se_linux_option", se_linux_option)

    @property
    @pulumi.getter
    def rule(self) -> str:
        """
        rule is the strategy that will dictate the allowable labels that may be set.
        """
        return pulumi.get(self, "rule")

    @property
    @pulumi.getter(name="seLinuxOption")
    def se_linux_option(self) -> Optional['outputs.GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult']:
        """
        seLinuxOptions required to run as; required for MustRunAs. More info: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
        """
        return pulumi.get(self, "se_linux_option")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSeLinuxSeLinuxOptionResult(dict):
    def __init__(__self__, *,
                 level: Optional[str] = None,
                 role: Optional[str] = None,
                 type: Optional[str] = None,
                 user: Optional[str] = None):
        """
        :param str level: Level is SELinux level label that applies to the container.
        :param str role: Role is a SELinux role label that applies to the container.
        :param str type: Type is a SELinux type label that applies to the container.
        :param str user: User is a SELinux user label that applies to the container.
        """
        if level is not None:
            pulumi.set(__self__, "level", level)
        if role is not None:
            pulumi.set(__self__, "role", role)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @property
    @pulumi.getter
    def level(self) -> Optional[str]:
        """
        Level is SELinux level label that applies to the container.
        """
        return pulumi.get(self, "level")

    @property
    @pulumi.getter
    def role(self) -> Optional[str]:
        """
        Role is a SELinux role label that applies to the container.
        """
        return pulumi.get(self, "role")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        """
        Type is a SELinux type label that applies to the container.
        """
        return pulumi.get(self, "type")

    @property
    @pulumi.getter
    def user(self) -> Optional[str]:
        """
        User is a SELinux user label that applies to the container.
        """
        return pulumi.get(self, "user")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSupplementalGroupResult(dict):
    def __init__(__self__, *,
                 ranges: Sequence['outputs.GetPodSecurityPolicyTemplateSupplementalGroupRangeResult'],
                 rule: Optional[str] = None):
        """
        :param Sequence['GetPodSecurityPolicyTemplateSupplementalGroupRangeArgs'] ranges: ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        :param str rule: rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        pulumi.set(__self__, "ranges", ranges)
        if rule is not None:
            pulumi.set(__self__, "rule", rule)

    @property
    @pulumi.getter
    def ranges(self) -> Sequence['outputs.GetPodSecurityPolicyTemplateSupplementalGroupRangeResult']:
        """
        ranges are the allowed ranges of supplemental groups.  If you would like to force a single supplemental group then supply a single range with the same start and end. Required for MustRunAs.
        """
        return pulumi.get(self, "ranges")

    @property
    @pulumi.getter
    def rule(self) -> Optional[str]:
        """
        rule is the strategy that will dictate what supplemental groups is used in the SecurityContext.
        """
        return pulumi.get(self, "rule")


@pulumi.output_type
class GetPodSecurityPolicyTemplateSupplementalGroupRangeResult(dict):
    def __init__(__self__, *,
                 max: int,
                 min: int):
        """
        :param int max: max is the end of the range, inclusive.
        :param int min: min is the start of the range, inclusive.
        """
        pulumi.set(__self__, "max", max)
        pulumi.set(__self__, "min", min)

    @property
    @pulumi.getter
    def max(self) -> int:
        """
        max is the end of the range, inclusive.
        """
        return pulumi.get(self, "max")

    @property
    @pulumi.getter
    def min(self) -> int:
        """
        min is the start of the range, inclusive.
        """
        return pulumi.get(self, "min")


@pulumi.output_type
class GetProjectAlertGroupRecipientResult(dict):
    def __init__(__self__, *,
                 notifier_id: str,
                 notifier_type: str,
                 recipient: str,
                 default_recipient: Optional[bool] = None):
        """
        :param str notifier_id: Recipient notifier ID
        :param str notifier_type: Recipient notifier type
        :param str recipient: Recipient
        :param bool default_recipient: Use notifier default recipient
        """
        pulumi.set(__self__, "notifier_id", notifier_id)
        pulumi.set(__self__, "notifier_type", notifier_type)
        pulumi.set(__self__, "recipient", recipient)
        if default_recipient is not None:
            pulumi.set(__self__, "default_recipient", default_recipient)

    @property
    @pulumi.getter(name="notifierId")
    def notifier_id(self) -> str:
        """
        Recipient notifier ID
        """
        return pulumi.get(self, "notifier_id")

    @property
    @pulumi.getter(name="notifierType")
    def notifier_type(self) -> str:
        """
        Recipient notifier type
        """
        return pulumi.get(self, "notifier_type")

    @property
    @pulumi.getter
    def recipient(self) -> str:
        """
        Recipient
        """
        return pulumi.get(self, "recipient")

    @property
    @pulumi.getter(name="defaultRecipient")
    def default_recipient(self) -> Optional[bool]:
        """
        Use notifier default recipient
        """
        return pulumi.get(self, "default_recipient")


@pulumi.output_type
class GetProjectAlertRuleMetricRuleResult(dict):
    def __init__(__self__, *,
                 duration: str,
                 expression: str,
                 threshold_value: float,
                 comparison: Optional[str] = None,
                 description: Optional[str] = None):
        """
        :param str duration: Metric rule duration
        :param str expression: Metric rule expression
        :param float threshold_value: Metric rule threshold value
        :param str comparison: Metric rule comparison
        :param str description: Metric rule description
        """
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "expression", expression)
        pulumi.set(__self__, "threshold_value", threshold_value)
        if comparison is not None:
            pulumi.set(__self__, "comparison", comparison)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @property
    @pulumi.getter
    def duration(self) -> str:
        """
        Metric rule duration
        """
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter
    def expression(self) -> str:
        """
        Metric rule expression
        """
        return pulumi.get(self, "expression")

    @property
    @pulumi.getter(name="thresholdValue")
    def threshold_value(self) -> float:
        """
        Metric rule threshold value
        """
        return pulumi.get(self, "threshold_value")

    @property
    @pulumi.getter
    def comparison(self) -> Optional[str]:
        """
        Metric rule comparison
        """
        return pulumi.get(self, "comparison")

    @property
    @pulumi.getter
    def description(self) -> Optional[str]:
        """
        Metric rule description
        """
        return pulumi.get(self, "description")


@pulumi.output_type
class GetProjectAlertRulePodRuleResult(dict):
    def __init__(__self__, *,
                 pod_id: str,
                 condition: Optional[str] = None,
                 restart_interval_seconds: Optional[int] = None,
                 restart_times: Optional[int] = None):
        """
        :param str pod_id: Pod ID
        :param str condition: Pod rule condition
        :param int restart_interval_seconds: Pod rule restart interval seconds
        :param int restart_times: Pod rule restart times
        """
        pulumi.set(__self__, "pod_id", pod_id)
        if condition is not None:
            pulumi.set(__self__, "condition", condition)
        if restart_interval_seconds is not None:
            pulumi.set(__self__, "restart_interval_seconds", restart_interval_seconds)
        if restart_times is not None:
            pulumi.set(__self__, "restart_times", restart_times)

    @property
    @pulumi.getter(name="podId")
    def pod_id(self) -> str:
        """
        Pod ID
        """
        return pulumi.get(self, "pod_id")

    @property
    @pulumi.getter
    def condition(self) -> Optional[str]:
        """
        Pod rule condition
        """
        return pulumi.get(self, "condition")

    @property
    @pulumi.getter(name="restartIntervalSeconds")
    def restart_interval_seconds(self) -> Optional[int]:
        """
        Pod rule restart interval seconds
        """
        return pulumi.get(self, "restart_interval_seconds")

    @property
    @pulumi.getter(name="restartTimes")
    def restart_times(self) -> Optional[int]:
        """
        Pod rule restart times
        """
        return pulumi.get(self, "restart_times")


@pulumi.output_type
class GetProjectAlertRuleWorkloadRuleResult(dict):
    def __init__(__self__, *,
                 available_percentage: Optional[int] = None,
                 selector: Optional[Mapping[str, Any]] = None,
                 workload_id: Optional[str] = None):
        """
        :param int available_percentage: Workload rule available percentage
        :param Mapping[str, Any] selector: Workload rule selector
        :param str workload_id: Workload ID
        """
        if available_percentage is not None:
            pulumi.set(__self__, "available_percentage", available_percentage)
        if selector is not None:
            pulumi.set(__self__, "selector", selector)
        if workload_id is not None:
            pulumi.set(__self__, "workload_id", workload_id)

    @property
    @pulumi.getter(name="availablePercentage")
    def available_percentage(self) -> Optional[int]:
        """
        Workload rule available percentage
        """
        return pulumi.get(self, "available_percentage")

    @property
    @pulumi.getter
    def selector(self) -> Optional[Mapping[str, Any]]:
        """
        Workload rule selector
        """
        return pulumi.get(self, "selector")

    @property
    @pulumi.getter(name="workloadId")
    def workload_id(self) -> Optional[str]:
        """
        Workload ID
        """
        return pulumi.get(self, "workload_id")


@pulumi.output_type
class GetProjectContainerResourceLimitResult(dict):
    def __init__(__self__, *,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None):
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")


@pulumi.output_type
class GetProjectResourceQuotaResult(dict):
    def __init__(__self__, *,
                 namespace_default_limit: 'outputs.GetProjectResourceQuotaNamespaceDefaultLimitResult',
                 project_limit: 'outputs.GetProjectResourceQuotaProjectLimitResult'):
        pulumi.set(__self__, "namespace_default_limit", namespace_default_limit)
        pulumi.set(__self__, "project_limit", project_limit)

    @property
    @pulumi.getter(name="namespaceDefaultLimit")
    def namespace_default_limit(self) -> 'outputs.GetProjectResourceQuotaNamespaceDefaultLimitResult':
        return pulumi.get(self, "namespace_default_limit")

    @property
    @pulumi.getter(name="projectLimit")
    def project_limit(self) -> 'outputs.GetProjectResourceQuotaProjectLimitResult':
        return pulumi.get(self, "project_limit")


@pulumi.output_type
class GetProjectResourceQuotaNamespaceDefaultLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetProjectResourceQuotaProjectLimitResult(dict):
    def __init__(__self__, *,
                 config_maps: Optional[str] = None,
                 limits_cpu: Optional[str] = None,
                 limits_memory: Optional[str] = None,
                 persistent_volume_claims: Optional[str] = None,
                 pods: Optional[str] = None,
                 replication_controllers: Optional[str] = None,
                 requests_cpu: Optional[str] = None,
                 requests_memory: Optional[str] = None,
                 requests_storage: Optional[str] = None,
                 secrets: Optional[str] = None,
                 services: Optional[str] = None,
                 services_load_balancers: Optional[str] = None,
                 services_node_ports: Optional[str] = None):
        if config_maps is not None:
            pulumi.set(__self__, "config_maps", config_maps)
        if limits_cpu is not None:
            pulumi.set(__self__, "limits_cpu", limits_cpu)
        if limits_memory is not None:
            pulumi.set(__self__, "limits_memory", limits_memory)
        if persistent_volume_claims is not None:
            pulumi.set(__self__, "persistent_volume_claims", persistent_volume_claims)
        if pods is not None:
            pulumi.set(__self__, "pods", pods)
        if replication_controllers is not None:
            pulumi.set(__self__, "replication_controllers", replication_controllers)
        if requests_cpu is not None:
            pulumi.set(__self__, "requests_cpu", requests_cpu)
        if requests_memory is not None:
            pulumi.set(__self__, "requests_memory", requests_memory)
        if requests_storage is not None:
            pulumi.set(__self__, "requests_storage", requests_storage)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if services is not None:
            pulumi.set(__self__, "services", services)
        if services_load_balancers is not None:
            pulumi.set(__self__, "services_load_balancers", services_load_balancers)
        if services_node_ports is not None:
            pulumi.set(__self__, "services_node_ports", services_node_ports)

    @property
    @pulumi.getter(name="configMaps")
    def config_maps(self) -> Optional[str]:
        return pulumi.get(self, "config_maps")

    @property
    @pulumi.getter(name="limitsCpu")
    def limits_cpu(self) -> Optional[str]:
        return pulumi.get(self, "limits_cpu")

    @property
    @pulumi.getter(name="limitsMemory")
    def limits_memory(self) -> Optional[str]:
        return pulumi.get(self, "limits_memory")

    @property
    @pulumi.getter(name="persistentVolumeClaims")
    def persistent_volume_claims(self) -> Optional[str]:
        return pulumi.get(self, "persistent_volume_claims")

    @property
    @pulumi.getter
    def pods(self) -> Optional[str]:
        return pulumi.get(self, "pods")

    @property
    @pulumi.getter(name="replicationControllers")
    def replication_controllers(self) -> Optional[str]:
        return pulumi.get(self, "replication_controllers")

    @property
    @pulumi.getter(name="requestsCpu")
    def requests_cpu(self) -> Optional[str]:
        return pulumi.get(self, "requests_cpu")

    @property
    @pulumi.getter(name="requestsMemory")
    def requests_memory(self) -> Optional[str]:
        return pulumi.get(self, "requests_memory")

    @property
    @pulumi.getter(name="requestsStorage")
    def requests_storage(self) -> Optional[str]:
        return pulumi.get(self, "requests_storage")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[str]:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def services(self) -> Optional[str]:
        return pulumi.get(self, "services")

    @property
    @pulumi.getter(name="servicesLoadBalancers")
    def services_load_balancers(self) -> Optional[str]:
        return pulumi.get(self, "services_load_balancers")

    @property
    @pulumi.getter(name="servicesNodePorts")
    def services_node_ports(self) -> Optional[str]:
        return pulumi.get(self, "services_node_ports")


@pulumi.output_type
class GetRegistryRegistryResult(dict):
    def __init__(__self__, *,
                 address: str,
                 password: Optional[str] = None,
                 username: Optional[str] = None):
        pulumi.set(__self__, "address", address)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def address(self) -> str:
        return pulumi.get(self, "address")

    @property
    @pulumi.getter
    def password(self) -> Optional[str]:
        return pulumi.get(self, "password")

    @property
    @pulumi.getter
    def username(self) -> Optional[str]:
        return pulumi.get(self, "username")


@pulumi.output_type
class GetRoleTemplateRuleResult(dict):
    def __init__(__self__, *,
                 api_groups: Optional[Sequence[str]] = None,
                 non_resource_urls: Optional[Sequence[str]] = None,
                 resource_names: Optional[Sequence[str]] = None,
                 resources: Optional[Sequence[str]] = None,
                 verbs: Optional[Sequence[str]] = None):
        """
        :param Sequence[str] api_groups: Policy rule api groups
        :param Sequence[str] non_resource_urls: Policy rule non resource urls
        :param Sequence[str] resource_names: Policy rule resource names
        :param Sequence[str] resources: Policy rule resources
        :param Sequence[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[str]]:
        """
        Policy rule api groups
        """
        return pulumi.get(self, "api_groups")

    @property
    @pulumi.getter(name="nonResourceUrls")
    def non_resource_urls(self) -> Optional[Sequence[str]]:
        """
        Policy rule non resource urls
        """
        return pulumi.get(self, "non_resource_urls")

    @property
    @pulumi.getter(name="resourceNames")
    def resource_names(self) -> Optional[Sequence[str]]:
        """
        Policy rule resource names
        """
        return pulumi.get(self, "resource_names")

    @property
    @pulumi.getter
    def resources(self) -> Optional[Sequence[str]]:
        """
        Policy rule resources
        """
        return pulumi.get(self, "resources")

    @property
    @pulumi.getter
    def verbs(self) -> Optional[Sequence[str]]:
        """
        Policy rule verbs
        """
        return pulumi.get(self, "verbs")


