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

__all__ = [
    'DataIntegrationS3',
    'ElastigroupAzureV3Extension',
    'ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault',
    'ElastigroupAzureV3Image',
    'ElastigroupAzureV3ImageCustom',
    'ElastigroupAzureV3ImageGalleryImage',
    'ElastigroupAzureV3ImageMarketplace',
    'ElastigroupAzureV3Login',
    'ElastigroupAzureV3ManagedServiceIdentity',
    'ElastigroupAzureV3Network',
    'ElastigroupAzureV3NetworkNetworkInterface',
    'ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig',
    'ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup',
    'ElastigroupAzureV3ScalingDownPolicy',
    'ElastigroupAzureV3ScalingDownPolicyAction',
    'ElastigroupAzureV3ScalingDownPolicyDimension',
    'ElastigroupAzureV3ScalingUpPolicy',
    'ElastigroupAzureV3ScalingUpPolicyAction',
    'ElastigroupAzureV3ScalingUpPolicyDimension',
    'ElastigroupAzureV3Tag',
    'ElastigroupAzureV3VmSizes',
    'HealthCheckCheck',
    'OceanRightSizingRuleAttachWorkload',
    'OceanRightSizingRuleAttachWorkloadNamespace',
    'OceanRightSizingRuleAttachWorkloadNamespaceLabel',
    'OceanRightSizingRuleAttachWorkloadNamespaceWorkload',
    'OceanRightSizingRuleDetachWorkload',
    'OceanRightSizingRuleDetachWorkloadNamespace',
    'OceanRightSizingRuleDetachWorkloadNamespaceLabel',
    'OceanRightSizingRuleDetachWorkloadNamespaceWorkload',
    'OceanRightSizingRuleRecommendationApplicationBoundary',
    'OceanRightSizingRuleRecommendationApplicationInterval',
    'OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase',
    'OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBaseWeeklyRepetitionBase',
    'OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase',
    'OceanRightSizingRuleRecommendationApplicationMinThreshold',
    'OceanRightSizingRuleRecommendationApplicationOverheadValue',
    'StatefulNodeAzureAttachDataDisk',
    'StatefulNodeAzureBootDiagnostic',
    'StatefulNodeAzureDataDisk',
    'StatefulNodeAzureDelete',
    'StatefulNodeAzureDetachDataDisk',
    'StatefulNodeAzureExtension',
    'StatefulNodeAzureHealth',
    'StatefulNodeAzureImage',
    'StatefulNodeAzureImageCustomImage',
    'StatefulNodeAzureImageGallery',
    'StatefulNodeAzureImageMarketplaceImage',
    'StatefulNodeAzureImportVm',
    'StatefulNodeAzureLoadBalancer',
    'StatefulNodeAzureLogin',
    'StatefulNodeAzureManagedServiceIdentity',
    'StatefulNodeAzureNetwork',
    'StatefulNodeAzureNetworkNetworkInterface',
    'StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration',
    'StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup',
    'StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup',
    'StatefulNodeAzureNetworkNetworkInterfacePublicIp',
    'StatefulNodeAzureOsDisk',
    'StatefulNodeAzureProximityPlacementGroup',
    'StatefulNodeAzureSchedulingTask',
    'StatefulNodeAzureSecret',
    'StatefulNodeAzureSecretSourceVault',
    'StatefulNodeAzureSecretVaultCertificate',
    'StatefulNodeAzureSecurity',
    'StatefulNodeAzureSignal',
    'StatefulNodeAzureStrategy',
    'StatefulNodeAzureStrategyCapacityReservation',
    'StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup',
    'StatefulNodeAzureStrategyRevertToSpot',
    'StatefulNodeAzureTag',
    'StatefulNodeAzureUpdateState',
    'StatefulNodeAzureVmSizes',
]

@pulumi.output_type
class DataIntegrationS3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bucketName":
            suggest = "bucket_name"

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

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

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

    def __init__(__self__, *,
                 bucket_name: str,
                 subdir: Optional[str] = None):
        """
        :param str subdir: The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
        """
        pulumi.set(__self__, "bucket_name", bucket_name)
        if subdir is not None:
            pulumi.set(__self__, "subdir", subdir)

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

    @property
    @pulumi.getter
    def subdir(self) -> Optional[str]:
        """
        The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
        """
        return pulumi.get(self, "subdir")


@pulumi.output_type
class ElastigroupAzureV3Extension(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"
        elif key == "minorVersionAutoUpgrade":
            suggest = "minor_version_auto_upgrade"
        elif key == "enableAutomaticUpgrade":
            suggest = "enable_automatic_upgrade"
        elif key == "protectedSettings":
            suggest = "protected_settings"
        elif key == "protectedSettingsFromKeyVault":
            suggest = "protected_settings_from_key_vault"
        elif key == "publicSettings":
            suggest = "public_settings"

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

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

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

    def __init__(__self__, *,
                 api_version: str,
                 minor_version_auto_upgrade: bool,
                 name: str,
                 publisher: str,
                 type: str,
                 enable_automatic_upgrade: Optional[bool] = None,
                 protected_settings: Optional[Mapping[str, str]] = None,
                 protected_settings_from_key_vault: Optional['outputs.ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault'] = None,
                 public_settings: Optional[Mapping[str, str]] = None):
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "publisher", publisher)
        pulumi.set(__self__, "type", type)
        if enable_automatic_upgrade is not None:
            pulumi.set(__self__, "enable_automatic_upgrade", enable_automatic_upgrade)
        if protected_settings is not None:
            pulumi.set(__self__, "protected_settings", protected_settings)
        if protected_settings_from_key_vault is not None:
            pulumi.set(__self__, "protected_settings_from_key_vault", protected_settings_from_key_vault)
        if public_settings is not None:
            pulumi.set(__self__, "public_settings", public_settings)

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

    @property
    @pulumi.getter(name="minorVersionAutoUpgrade")
    def minor_version_auto_upgrade(self) -> bool:
        return pulumi.get(self, "minor_version_auto_upgrade")

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

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

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

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

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

    @property
    @pulumi.getter(name="protectedSettingsFromKeyVault")
    def protected_settings_from_key_vault(self) -> Optional['outputs.ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault']:
        return pulumi.get(self, "protected_settings_from_key_vault")

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


@pulumi.output_type
class ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretUrl":
            suggest = "secret_url"
        elif key == "sourceVault":
            suggest = "source_vault"

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

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

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

    def __init__(__self__, *,
                 secret_url: str,
                 source_vault: str):
        pulumi.set(__self__, "secret_url", secret_url)
        pulumi.set(__self__, "source_vault", source_vault)

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

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


@pulumi.output_type
class ElastigroupAzureV3Image(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "galleryImages":
            suggest = "gallery_images"

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

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

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

    def __init__(__self__, *,
                 customs: Optional[Sequence['outputs.ElastigroupAzureV3ImageCustom']] = None,
                 gallery_images: Optional[Sequence['outputs.ElastigroupAzureV3ImageGalleryImage']] = None,
                 marketplaces: Optional[Sequence['outputs.ElastigroupAzureV3ImageMarketplace']] = None):
        if customs is not None:
            pulumi.set(__self__, "customs", customs)
        if gallery_images is not None:
            pulumi.set(__self__, "gallery_images", gallery_images)
        if marketplaces is not None:
            pulumi.set(__self__, "marketplaces", marketplaces)

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

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

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


@pulumi.output_type
class ElastigroupAzureV3ImageCustom(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageName":
            suggest = "image_name"
        elif key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 image_name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class ElastigroupAzureV3ImageGalleryImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "galleryName":
            suggest = "gallery_name"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "resourceGroupName":
            suggest = "resource_group_name"
        elif key == "spotAccountId":
            suggest = "spot_account_id"

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

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

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

    def __init__(__self__, *,
                 gallery_name: str,
                 image_name: str,
                 resource_group_name: str,
                 version: str,
                 spot_account_id: Optional[str] = None):
        pulumi.set(__self__, "gallery_name", gallery_name)
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        pulumi.set(__self__, "version", version)
        if spot_account_id is not None:
            pulumi.set(__self__, "spot_account_id", spot_account_id)

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

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3ImageMarketplace(dict):
    def __init__(__self__, *,
                 offer: str,
                 publisher: str,
                 sku: str,
                 version: str):
        pulumi.set(__self__, "offer", offer)
        pulumi.set(__self__, "publisher", publisher)
        pulumi.set(__self__, "sku", sku)
        pulumi.set(__self__, "version", version)

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3Login(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "userName":
            suggest = "user_name"
        elif key == "sshPublicKey":
            suggest = "ssh_public_key"

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

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

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

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3ManagedServiceIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class ElastigroupAzureV3Network(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkInterfaces":
            suggest = "network_interfaces"
        elif key == "resourceGroupName":
            suggest = "resource_group_name"
        elif key == "virtualNetworkName":
            suggest = "virtual_network_name"

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

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

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

    def __init__(__self__, *,
                 network_interfaces: Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface'],
                 resource_group_name: str,
                 virtual_network_name: str):
        pulumi.set(__self__, "network_interfaces", network_interfaces)
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        pulumi.set(__self__, "virtual_network_name", virtual_network_name)

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface']:
        return pulumi.get(self, "network_interfaces")

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

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


@pulumi.output_type
class ElastigroupAzureV3NetworkNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "assignPublicIp":
            suggest = "assign_public_ip"
        elif key == "isPrimary":
            suggest = "is_primary"
        elif key == "subnetName":
            suggest = "subnet_name"
        elif key == "additionalIpConfigs":
            suggest = "additional_ip_configs"
        elif key == "applicationSecurityGroups":
            suggest = "application_security_groups"

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

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

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

    def __init__(__self__, *,
                 assign_public_ip: bool,
                 is_primary: bool,
                 subnet_name: str,
                 additional_ip_configs: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig']] = None,
                 application_security_groups: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup']] = None):
        pulumi.set(__self__, "assign_public_ip", assign_public_ip)
        pulumi.set(__self__, "is_primary", is_primary)
        pulumi.set(__self__, "subnet_name", subnet_name)
        if additional_ip_configs is not None:
            pulumi.set(__self__, "additional_ip_configs", additional_ip_configs)
        if application_security_groups is not None:
            pulumi.set(__self__, "application_security_groups", application_security_groups)

    @property
    @pulumi.getter(name="assignPublicIp")
    def assign_public_ip(self) -> bool:
        return pulumi.get(self, "assign_public_ip")

    @property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> bool:
        return pulumi.get(self, "is_primary")

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

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

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


@pulumi.output_type
class ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpVersion":
            suggest = "private_ip_version"

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

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

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class ElastigroupAzureV3ScalingDownPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evaluationPeriods":
            suggest = "evaluation_periods"
        elif key == "metricName":
            suggest = "metric_name"
        elif key == "policyName":
            suggest = "policy_name"
        elif key == "isEnabled":
            suggest = "is_enabled"

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

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

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

    def __init__(__self__, *,
                 action: 'outputs.ElastigroupAzureV3ScalingDownPolicyAction',
                 cooldown: int,
                 evaluation_periods: int,
                 metric_name: str,
                 namespace: str,
                 operator: str,
                 period: int,
                 policy_name: str,
                 statistic: str,
                 threshold: float,
                 dimensions: Optional[Sequence['outputs.ElastigroupAzureV3ScalingDownPolicyDimension']] = None,
                 is_enabled: Optional[bool] = None,
                 source: Optional[str] = None,
                 unit: Optional[str] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "cooldown", cooldown)
        pulumi.set(__self__, "evaluation_periods", evaluation_periods)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "policy_name", policy_name)
        pulumi.set(__self__, "statistic", statistic)
        pulumi.set(__self__, "threshold", threshold)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

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

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

    @property
    @pulumi.getter(name="evaluationPeriods")
    def evaluation_periods(self) -> int:
        return pulumi.get(self, "evaluation_periods")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3ScalingDownPolicyAction(dict):
    def __init__(__self__, *,
                 adjustment: Optional[str] = None,
                 maximum: Optional[str] = None,
                 minimum: Optional[str] = None,
                 target: Optional[str] = None,
                 type: Optional[str] = None):
        if adjustment is not None:
            pulumi.set(__self__, "adjustment", adjustment)
        if maximum is not None:
            pulumi.set(__self__, "maximum", maximum)
        if minimum is not None:
            pulumi.set(__self__, "minimum", minimum)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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


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

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

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


@pulumi.output_type
class ElastigroupAzureV3ScalingUpPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "evaluationPeriods":
            suggest = "evaluation_periods"
        elif key == "metricName":
            suggest = "metric_name"
        elif key == "policyName":
            suggest = "policy_name"
        elif key == "isEnabled":
            suggest = "is_enabled"

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

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

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

    def __init__(__self__, *,
                 action: 'outputs.ElastigroupAzureV3ScalingUpPolicyAction',
                 cooldown: int,
                 evaluation_periods: int,
                 metric_name: str,
                 namespace: str,
                 operator: str,
                 period: int,
                 policy_name: str,
                 statistic: str,
                 threshold: float,
                 dimensions: Optional[Sequence['outputs.ElastigroupAzureV3ScalingUpPolicyDimension']] = None,
                 is_enabled: Optional[bool] = None,
                 source: Optional[str] = None,
                 unit: Optional[str] = None):
        pulumi.set(__self__, "action", action)
        pulumi.set(__self__, "cooldown", cooldown)
        pulumi.set(__self__, "evaluation_periods", evaluation_periods)
        pulumi.set(__self__, "metric_name", metric_name)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "operator", operator)
        pulumi.set(__self__, "period", period)
        pulumi.set(__self__, "policy_name", policy_name)
        pulumi.set(__self__, "statistic", statistic)
        pulumi.set(__self__, "threshold", threshold)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if is_enabled is not None:
            pulumi.set(__self__, "is_enabled", is_enabled)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

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

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

    @property
    @pulumi.getter(name="evaluationPeriods")
    def evaluation_periods(self) -> int:
        return pulumi.get(self, "evaluation_periods")

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class ElastigroupAzureV3ScalingUpPolicyAction(dict):
    def __init__(__self__, *,
                 adjustment: Optional[str] = None,
                 maximum: Optional[str] = None,
                 minimum: Optional[str] = None,
                 target: Optional[str] = None,
                 type: Optional[str] = None):
        if adjustment is not None:
            pulumi.set(__self__, "adjustment", adjustment)
        if maximum is not None:
            pulumi.set(__self__, "maximum", maximum)
        if minimum is not None:
            pulumi.set(__self__, "minimum", minimum)
        if target is not None:
            pulumi.set(__self__, "target", target)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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


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

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

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


@pulumi.output_type
class ElastigroupAzureV3Tag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @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 ElastigroupAzureV3VmSizes(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "odSizes":
            suggest = "od_sizes"
        elif key == "spotSizes":
            suggest = "spot_sizes"

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

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

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

    def __init__(__self__, *,
                 od_sizes: Sequence[str],
                 spot_sizes: Sequence[str]):
        pulumi.set(__self__, "od_sizes", od_sizes)
        pulumi.set(__self__, "spot_sizes", spot_sizes)

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

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


@pulumi.output_type
class HealthCheckCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endPoint":
            suggest = "end_point"
        elif key == "timeOut":
            suggest = "time_out"

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

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

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

    def __init__(__self__, *,
                 healthy: int,
                 interval: int,
                 port: int,
                 protocol: str,
                 unhealthy: int,
                 end_point: Optional[str] = None,
                 endpoint: Optional[str] = None,
                 time_out: Optional[int] = None,
                 timeout: Optional[int] = None):
        """
        :param int healthy: The number of consecutive successful health checks that must occur before declaring an instance healthy.
        :param int interval: The amount of time (in seconds) between each health check (minimum: 10).
        :param int port: The port to use to connect with the instance.
        :param str protocol: The protocol to use to connect with the instance. Valid values: http, https.
        :param int unhealthy: The number of consecutive failed health checks that must occur before declaring an instance unhealthy.
        :param str endpoint: The destination for the request.
        :param int timeout: the amount of time (in seconds) to wait when receiving a response from the health check.
        """
        pulumi.set(__self__, "healthy", healthy)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        pulumi.set(__self__, "unhealthy", unhealthy)
        if end_point is not None:
            pulumi.set(__self__, "end_point", end_point)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if time_out is not None:
            pulumi.set(__self__, "time_out", time_out)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def healthy(self) -> int:
        """
        The number of consecutive successful health checks that must occur before declaring an instance healthy.
        """
        return pulumi.get(self, "healthy")

    @property
    @pulumi.getter
    def interval(self) -> int:
        """
        The amount of time (in seconds) between each health check (minimum: 10).
        """
        return pulumi.get(self, "interval")

    @property
    @pulumi.getter
    def port(self) -> int:
        """
        The port to use to connect with the instance.
        """
        return pulumi.get(self, "port")

    @property
    @pulumi.getter
    def protocol(self) -> str:
        """
        The protocol to use to connect with the instance. Valid values: http, https.
        """
        return pulumi.get(self, "protocol")

    @property
    @pulumi.getter
    def unhealthy(self) -> int:
        """
        The number of consecutive failed health checks that must occur before declaring an instance unhealthy.
        """
        return pulumi.get(self, "unhealthy")

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

    @property
    @pulumi.getter
    def endpoint(self) -> Optional[str]:
        """
        The destination for the request.
        """
        return pulumi.get(self, "endpoint")

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

    @property
    @pulumi.getter
    def timeout(self) -> Optional[int]:
        """
        the amount of time (in seconds) to wait when receiving a response from the health check.
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class OceanRightSizingRuleAttachWorkload(dict):
    def __init__(__self__, *,
                 namespaces: Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespace']):
        pulumi.set(__self__, "namespaces", namespaces)

    @property
    @pulumi.getter
    def namespaces(self) -> Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespace']:
        return pulumi.get(self, "namespaces")


@pulumi.output_type
class OceanRightSizingRuleAttachWorkloadNamespace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceName":
            suggest = "namespace_name"

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

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

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

    def __init__(__self__, *,
                 namespace_name: str,
                 labels: Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceLabel']] = None,
                 workloads: Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceWorkload']] = None):
        pulumi.set(__self__, "namespace_name", namespace_name)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if workloads is not None:
            pulumi.set(__self__, "workloads", workloads)

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

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

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


@pulumi.output_type
class OceanRightSizingRuleAttachWorkloadNamespaceLabel(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @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 OceanRightSizingRuleAttachWorkloadNamespaceWorkload(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "workloadType":
            suggest = "workload_type"
        elif key == "regexName":
            suggest = "regex_name"
        elif key == "workloadName":
            suggest = "workload_name"

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

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

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

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

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

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

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


@pulumi.output_type
class OceanRightSizingRuleDetachWorkload(dict):
    def __init__(__self__, *,
                 namespaces: Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespace']):
        pulumi.set(__self__, "namespaces", namespaces)

    @property
    @pulumi.getter
    def namespaces(self) -> Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespace']:
        return pulumi.get(self, "namespaces")


@pulumi.output_type
class OceanRightSizingRuleDetachWorkloadNamespace(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "namespaceName":
            suggest = "namespace_name"

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

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

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

    def __init__(__self__, *,
                 namespace_name: str,
                 labels: Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceLabel']] = None,
                 workloads: Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceWorkload']] = None):
        pulumi.set(__self__, "namespace_name", namespace_name)
        if labels is not None:
            pulumi.set(__self__, "labels", labels)
        if workloads is not None:
            pulumi.set(__self__, "workloads", workloads)

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

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

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


@pulumi.output_type
class OceanRightSizingRuleDetachWorkloadNamespaceLabel(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @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 OceanRightSizingRuleDetachWorkloadNamespaceWorkload(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "workloadType":
            suggest = "workload_type"
        elif key == "regexName":
            suggest = "regex_name"
        elif key == "workloadName":
            suggest = "workload_name"

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

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

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

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

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationBoundary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuMax":
            suggest = "cpu_max"
        elif key == "cpuMin":
            suggest = "cpu_min"
        elif key == "memoryMax":
            suggest = "memory_max"
        elif key == "memoryMin":
            suggest = "memory_min"

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

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

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

    def __init__(__self__, *,
                 cpu_max: Optional[float] = None,
                 cpu_min: Optional[float] = None,
                 memory_max: Optional[int] = None,
                 memory_min: Optional[int] = None):
        if cpu_max is not None:
            pulumi.set(__self__, "cpu_max", cpu_max)
        if cpu_min is not None:
            pulumi.set(__self__, "cpu_min", cpu_min)
        if memory_max is not None:
            pulumi.set(__self__, "memory_max", memory_max)
        if memory_min is not None:
            pulumi.set(__self__, "memory_min", memory_min)

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

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationInterval(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repetitionBasis":
            suggest = "repetition_basis"
        elif key == "monthlyRepetitionBases":
            suggest = "monthly_repetition_bases"
        elif key == "weeklyRepetitionBases":
            suggest = "weekly_repetition_bases"

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

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

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

    def __init__(__self__, *,
                 repetition_basis: str,
                 monthly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase']] = None,
                 weekly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase']] = None):
        pulumi.set(__self__, "repetition_basis", repetition_basis)
        if monthly_repetition_bases is not None:
            pulumi.set(__self__, "monthly_repetition_bases", monthly_repetition_bases)
        if weekly_repetition_bases is not None:
            pulumi.set(__self__, "weekly_repetition_bases", weekly_repetition_bases)

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalMonths":
            suggest = "interval_months"
        elif key == "weekOfTheMonths":
            suggest = "week_of_the_months"
        elif key == "weeklyRepetitionBases":
            suggest = "weekly_repetition_bases"

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

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

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

    def __init__(__self__, *,
                 interval_months: Sequence[int],
                 week_of_the_months: Sequence[str],
                 weekly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBaseWeeklyRepetitionBase']] = None):
        pulumi.set(__self__, "interval_months", interval_months)
        pulumi.set(__self__, "week_of_the_months", week_of_the_months)
        if weekly_repetition_bases is not None:
            pulumi.set(__self__, "weekly_repetition_bases", weekly_repetition_bases)

    @property
    @pulumi.getter(name="intervalMonths")
    def interval_months(self) -> Sequence[int]:
        return pulumi.get(self, "interval_months")

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBaseWeeklyRepetitionBase(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalDays":
            suggest = "interval_days"
        elif key == "intervalHoursEndTime":
            suggest = "interval_hours_end_time"
        elif key == "intervalHoursStartTime":
            suggest = "interval_hours_start_time"

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

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

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

    def __init__(__self__, *,
                 interval_days: Sequence[str],
                 interval_hours_end_time: str,
                 interval_hours_start_time: str):
        pulumi.set(__self__, "interval_days", interval_days)
        pulumi.set(__self__, "interval_hours_end_time", interval_hours_end_time)
        pulumi.set(__self__, "interval_hours_start_time", interval_hours_start_time)

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "intervalDays":
            suggest = "interval_days"
        elif key == "intervalHoursEndTime":
            suggest = "interval_hours_end_time"
        elif key == "intervalHoursStartTime":
            suggest = "interval_hours_start_time"

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

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

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

    def __init__(__self__, *,
                 interval_days: Sequence[str],
                 interval_hours_end_time: str,
                 interval_hours_start_time: str):
        pulumi.set(__self__, "interval_days", interval_days)
        pulumi.set(__self__, "interval_hours_end_time", interval_hours_end_time)
        pulumi.set(__self__, "interval_hours_start_time", interval_hours_start_time)

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationMinThreshold(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuPercentage":
            suggest = "cpu_percentage"
        elif key == "memoryPercentage":
            suggest = "memory_percentage"

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

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

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

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

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

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


@pulumi.output_type
class OceanRightSizingRuleRecommendationApplicationOverheadValue(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cpuPercentage":
            suggest = "cpu_percentage"
        elif key == "memoryPercentage":
            suggest = "memory_percentage"

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureAttachDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataDiskName":
            suggest = "data_disk_name"
        elif key == "dataDiskResourceGroupName":
            suggest = "data_disk_resource_group_name"
        elif key == "sizeGb":
            suggest = "size_gb"
        elif key == "storageAccountType":
            suggest = "storage_account_type"

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

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

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

    def __init__(__self__, *,
                 data_disk_name: str,
                 data_disk_resource_group_name: str,
                 size_gb: int,
                 storage_account_type: str,
                 lun: Optional[int] = None,
                 zone: Optional[str] = None):
        pulumi.set(__self__, "data_disk_name", data_disk_name)
        pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
        pulumi.set(__self__, "size_gb", size_gb)
        pulumi.set(__self__, "storage_account_type", storage_account_type)
        if lun is not None:
            pulumi.set(__self__, "lun", lun)
        if zone is not None:
            pulumi.set(__self__, "zone", zone)

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

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

    @property
    @pulumi.getter(name="sizeGb")
    def size_gb(self) -> int:
        return pulumi.get(self, "size_gb")

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

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

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


@pulumi.output_type
class StatefulNodeAzureBootDiagnostic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isEnabled":
            suggest = "is_enabled"
        elif key == "storageUrl":
            suggest = "storage_url"

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

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sizeGb":
            suggest = "size_gb"

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

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

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

    def __init__(__self__, *,
                 lun: int,
                 size_gb: int,
                 type: str):
        pulumi.set(__self__, "lun", lun)
        pulumi.set(__self__, "size_gb", size_gb)
        pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter(name="sizeGb")
    def size_gb(self) -> int:
        return pulumi.get(self, "size_gb")

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


@pulumi.output_type
class StatefulNodeAzureDelete(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskShouldDeallocate":
            suggest = "disk_should_deallocate"
        elif key == "networkShouldDeallocate":
            suggest = "network_should_deallocate"
        elif key == "publicIpShouldDeallocate":
            suggest = "public_ip_should_deallocate"
        elif key == "shouldTerminateVm":
            suggest = "should_terminate_vm"
        elif key == "snapshotShouldDeallocate":
            suggest = "snapshot_should_deallocate"
        elif key == "diskTtlInHours":
            suggest = "disk_ttl_in_hours"
        elif key == "networkTtlInHours":
            suggest = "network_ttl_in_hours"
        elif key == "publicIpTtlInHours":
            suggest = "public_ip_ttl_in_hours"
        elif key == "shouldDeregisterFromLb":
            suggest = "should_deregister_from_lb"
        elif key == "snapshotTtlInHours":
            suggest = "snapshot_ttl_in_hours"

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

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

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

    def __init__(__self__, *,
                 disk_should_deallocate: bool,
                 network_should_deallocate: bool,
                 public_ip_should_deallocate: bool,
                 should_terminate_vm: bool,
                 snapshot_should_deallocate: bool,
                 disk_ttl_in_hours: Optional[int] = None,
                 network_ttl_in_hours: Optional[int] = None,
                 public_ip_ttl_in_hours: Optional[int] = None,
                 should_deregister_from_lb: Optional[bool] = None,
                 snapshot_ttl_in_hours: Optional[int] = None):
        pulumi.set(__self__, "disk_should_deallocate", disk_should_deallocate)
        pulumi.set(__self__, "network_should_deallocate", network_should_deallocate)
        pulumi.set(__self__, "public_ip_should_deallocate", public_ip_should_deallocate)
        pulumi.set(__self__, "should_terminate_vm", should_terminate_vm)
        pulumi.set(__self__, "snapshot_should_deallocate", snapshot_should_deallocate)
        if disk_ttl_in_hours is not None:
            pulumi.set(__self__, "disk_ttl_in_hours", disk_ttl_in_hours)
        if network_ttl_in_hours is not None:
            pulumi.set(__self__, "network_ttl_in_hours", network_ttl_in_hours)
        if public_ip_ttl_in_hours is not None:
            pulumi.set(__self__, "public_ip_ttl_in_hours", public_ip_ttl_in_hours)
        if should_deregister_from_lb is not None:
            pulumi.set(__self__, "should_deregister_from_lb", should_deregister_from_lb)
        if snapshot_ttl_in_hours is not None:
            pulumi.set(__self__, "snapshot_ttl_in_hours", snapshot_ttl_in_hours)

    @property
    @pulumi.getter(name="diskShouldDeallocate")
    def disk_should_deallocate(self) -> bool:
        return pulumi.get(self, "disk_should_deallocate")

    @property
    @pulumi.getter(name="networkShouldDeallocate")
    def network_should_deallocate(self) -> bool:
        return pulumi.get(self, "network_should_deallocate")

    @property
    @pulumi.getter(name="publicIpShouldDeallocate")
    def public_ip_should_deallocate(self) -> bool:
        return pulumi.get(self, "public_ip_should_deallocate")

    @property
    @pulumi.getter(name="shouldTerminateVm")
    def should_terminate_vm(self) -> bool:
        return pulumi.get(self, "should_terminate_vm")

    @property
    @pulumi.getter(name="snapshotShouldDeallocate")
    def snapshot_should_deallocate(self) -> bool:
        return pulumi.get(self, "snapshot_should_deallocate")

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureDetachDataDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dataDiskName":
            suggest = "data_disk_name"
        elif key == "dataDiskResourceGroupName":
            suggest = "data_disk_resource_group_name"
        elif key == "shouldDeallocate":
            suggest = "should_deallocate"
        elif key == "ttlInHours":
            suggest = "ttl_in_hours"

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

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

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

    def __init__(__self__, *,
                 data_disk_name: str,
                 data_disk_resource_group_name: str,
                 should_deallocate: bool,
                 ttl_in_hours: Optional[int] = None):
        pulumi.set(__self__, "data_disk_name", data_disk_name)
        pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
        pulumi.set(__self__, "should_deallocate", should_deallocate)
        if ttl_in_hours is not None:
            pulumi.set(__self__, "ttl_in_hours", ttl_in_hours)

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

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

    @property
    @pulumi.getter(name="shouldDeallocate")
    def should_deallocate(self) -> bool:
        return pulumi.get(self, "should_deallocate")

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


@pulumi.output_type
class StatefulNodeAzureExtension(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "apiVersion":
            suggest = "api_version"
        elif key == "minorVersionAutoUpgrade":
            suggest = "minor_version_auto_upgrade"
        elif key == "protectedSettings":
            suggest = "protected_settings"
        elif key == "publicSettings":
            suggest = "public_settings"

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

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

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

    def __init__(__self__, *,
                 api_version: str,
                 minor_version_auto_upgrade: bool,
                 name: str,
                 publisher: str,
                 type: str,
                 protected_settings: Optional[Mapping[str, str]] = None,
                 public_settings: Optional[Mapping[str, str]] = None):
        pulumi.set(__self__, "api_version", api_version)
        pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "publisher", publisher)
        pulumi.set(__self__, "type", type)
        if protected_settings is not None:
            pulumi.set(__self__, "protected_settings", protected_settings)
        if public_settings is not None:
            pulumi.set(__self__, "public_settings", public_settings)

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

    @property
    @pulumi.getter(name="minorVersionAutoUpgrade")
    def minor_version_auto_upgrade(self) -> bool:
        return pulumi.get(self, "minor_version_auto_upgrade")

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureHealth(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "autoHealing":
            suggest = "auto_healing"
        elif key == "healthCheckTypes":
            suggest = "health_check_types"
        elif key == "gracePeriod":
            suggest = "grace_period"
        elif key == "unhealthyDuration":
            suggest = "unhealthy_duration"

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

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

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

    def __init__(__self__, *,
                 auto_healing: bool,
                 health_check_types: Sequence[str],
                 grace_period: Optional[int] = None,
                 unhealthy_duration: Optional[int] = None):
        pulumi.set(__self__, "auto_healing", auto_healing)
        pulumi.set(__self__, "health_check_types", health_check_types)
        if grace_period is not None:
            pulumi.set(__self__, "grace_period", grace_period)
        if unhealthy_duration is not None:
            pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)

    @property
    @pulumi.getter(name="autoHealing")
    def auto_healing(self) -> bool:
        return pulumi.get(self, "auto_healing")

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

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

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


@pulumi.output_type
class StatefulNodeAzureImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customImages":
            suggest = "custom_images"
        elif key == "marketplaceImages":
            suggest = "marketplace_images"

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

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

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

    def __init__(__self__, *,
                 custom_images: Optional[Sequence['outputs.StatefulNodeAzureImageCustomImage']] = None,
                 galleries: Optional[Sequence['outputs.StatefulNodeAzureImageGallery']] = None,
                 marketplace_images: Optional[Sequence['outputs.StatefulNodeAzureImageMarketplaceImage']] = None):
        if custom_images is not None:
            pulumi.set(__self__, "custom_images", custom_images)
        if galleries is not None:
            pulumi.set(__self__, "galleries", galleries)
        if marketplace_images is not None:
            pulumi.set(__self__, "marketplace_images", marketplace_images)

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

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

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


@pulumi.output_type
class StatefulNodeAzureImageCustomImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "customImageResourceGroupName":
            suggest = "custom_image_resource_group_name"

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

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

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

    def __init__(__self__, *,
                 custom_image_resource_group_name: str,
                 name: str):
        pulumi.set(__self__, "custom_image_resource_group_name", custom_image_resource_group_name)
        pulumi.set(__self__, "name", name)

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

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


@pulumi.output_type
class StatefulNodeAzureImageGallery(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "galleryName":
            suggest = "gallery_name"
        elif key == "galleryResourceGroupName":
            suggest = "gallery_resource_group_name"
        elif key == "imageName":
            suggest = "image_name"
        elif key == "versionName":
            suggest = "version_name"
        elif key == "spotAccountId":
            suggest = "spot_account_id"

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

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

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

    def __init__(__self__, *,
                 gallery_name: str,
                 gallery_resource_group_name: str,
                 image_name: str,
                 version_name: str,
                 spot_account_id: Optional[str] = None):
        pulumi.set(__self__, "gallery_name", gallery_name)
        pulumi.set(__self__, "gallery_resource_group_name", gallery_resource_group_name)
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "version_name", version_name)
        if spot_account_id is not None:
            pulumi.set(__self__, "spot_account_id", spot_account_id)

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureImageMarketplaceImage(dict):
    def __init__(__self__, *,
                 offer: str,
                 publisher: str,
                 sku: str,
                 version: str):
        pulumi.set(__self__, "offer", offer)
        pulumi.set(__self__, "publisher", publisher)
        pulumi.set(__self__, "sku", sku)
        pulumi.set(__self__, "version", version)

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureImportVm(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "originalVmName":
            suggest = "original_vm_name"
        elif key == "resourceGroupName":
            suggest = "resource_group_name"
        elif key == "drainingTimeout":
            suggest = "draining_timeout"
        elif key == "resourcesRetentionTime":
            suggest = "resources_retention_time"

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

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

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

    def __init__(__self__, *,
                 original_vm_name: str,
                 resource_group_name: str,
                 draining_timeout: Optional[int] = None,
                 resources_retention_time: Optional[int] = None):
        pulumi.set(__self__, "original_vm_name", original_vm_name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        if draining_timeout is not None:
            pulumi.set(__self__, "draining_timeout", draining_timeout)
        if resources_retention_time is not None:
            pulumi.set(__self__, "resources_retention_time", resources_retention_time)

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureLoadBalancer(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "backendPoolNames":
            suggest = "backend_pool_names"
        elif key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 backend_pool_names: Sequence[str],
                 name: str,
                 resource_group_name: str,
                 type: str,
                 sku: Optional[str] = None):
        pulumi.set(__self__, "backend_pool_names", backend_pool_names)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)
        pulumi.set(__self__, "type", type)
        if sku is not None:
            pulumi.set(__self__, "sku", sku)

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureLogin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "userName":
            suggest = "user_name"
        elif key == "sshPublicKey":
            suggest = "ssh_public_key"

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

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureManagedServiceIdentity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class StatefulNodeAzureNetwork(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkInterfaces":
            suggest = "network_interfaces"
        elif key == "networkResourceGroupName":
            suggest = "network_resource_group_name"
        elif key == "virtualNetworkName":
            suggest = "virtual_network_name"

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

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

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

    def __init__(__self__, *,
                 network_interfaces: Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface'],
                 network_resource_group_name: str,
                 virtual_network_name: str):
        pulumi.set(__self__, "network_interfaces", network_interfaces)
        pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
        pulumi.set(__self__, "virtual_network_name", virtual_network_name)

    @property
    @pulumi.getter(name="networkInterfaces")
    def network_interfaces(self) -> Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface']:
        return pulumi.get(self, "network_interfaces")

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

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


@pulumi.output_type
class StatefulNodeAzureNetworkNetworkInterface(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isPrimary":
            suggest = "is_primary"
        elif key == "subnetName":
            suggest = "subnet_name"
        elif key == "additionalIpConfigurations":
            suggest = "additional_ip_configurations"
        elif key == "applicationSecurityGroups":
            suggest = "application_security_groups"
        elif key == "assignPublicIp":
            suggest = "assign_public_ip"
        elif key == "enableIpForwarding":
            suggest = "enable_ip_forwarding"
        elif key == "networkSecurityGroups":
            suggest = "network_security_groups"
        elif key == "privateIpAddresses":
            suggest = "private_ip_addresses"
        elif key == "publicIpSku":
            suggest = "public_ip_sku"
        elif key == "publicIps":
            suggest = "public_ips"

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

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

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

    def __init__(__self__, *,
                 is_primary: bool,
                 subnet_name: str,
                 additional_ip_configurations: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration']] = None,
                 application_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup']] = None,
                 assign_public_ip: Optional[bool] = None,
                 enable_ip_forwarding: Optional[bool] = None,
                 network_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup']] = None,
                 private_ip_addresses: Optional[Sequence[str]] = None,
                 public_ip_sku: Optional[str] = None,
                 public_ips: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfacePublicIp']] = None):
        pulumi.set(__self__, "is_primary", is_primary)
        pulumi.set(__self__, "subnet_name", subnet_name)
        if additional_ip_configurations is not None:
            pulumi.set(__self__, "additional_ip_configurations", additional_ip_configurations)
        if application_security_groups is not None:
            pulumi.set(__self__, "application_security_groups", application_security_groups)
        if assign_public_ip is not None:
            pulumi.set(__self__, "assign_public_ip", assign_public_ip)
        if enable_ip_forwarding is not None:
            pulumi.set(__self__, "enable_ip_forwarding", enable_ip_forwarding)
        if network_security_groups is not None:
            pulumi.set(__self__, "network_security_groups", network_security_groups)
        if private_ip_addresses is not None:
            pulumi.set(__self__, "private_ip_addresses", private_ip_addresses)
        if public_ip_sku is not None:
            pulumi.set(__self__, "public_ip_sku", public_ip_sku)
        if public_ips is not None:
            pulumi.set(__self__, "public_ips", public_ips)

    @property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> bool:
        return pulumi.get(self, "is_primary")

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "privateIpAddressVersion":
            suggest = "private_ip_address_version"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 private_ip_address_version: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)

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

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


@pulumi.output_type
class StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkResourceGroupName":
            suggest = "network_resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 network_resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)

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

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


@pulumi.output_type
class StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkResourceGroupName":
            suggest = "network_resource_group_name"

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureNetworkNetworkInterfacePublicIp(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "networkResourceGroupName":
            suggest = "network_resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 network_resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)

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

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


@pulumi.output_type
class StatefulNodeAzureOsDisk(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sizeGb":
            suggest = "size_gb"

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

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureProximityPlacementGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class StatefulNodeAzureSchedulingTask(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cronExpression":
            suggest = "cron_expression"
        elif key == "isEnabled":
            suggest = "is_enabled"

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

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

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

    def __init__(__self__, *,
                 cron_expression: str,
                 is_enabled: bool,
                 type: str):
        pulumi.set(__self__, "cron_expression", cron_expression)
        pulumi.set(__self__, "is_enabled", is_enabled)
        pulumi.set(__self__, "type", type)

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

    @property
    @pulumi.getter(name="isEnabled")
    def is_enabled(self) -> bool:
        return pulumi.get(self, "is_enabled")

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


@pulumi.output_type
class StatefulNodeAzureSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceVaults":
            suggest = "source_vaults"
        elif key == "vaultCertificates":
            suggest = "vault_certificates"

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

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

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

    def __init__(__self__, *,
                 source_vaults: Sequence['outputs.StatefulNodeAzureSecretSourceVault'],
                 vault_certificates: Sequence['outputs.StatefulNodeAzureSecretVaultCertificate']):
        pulumi.set(__self__, "source_vaults", source_vaults)
        pulumi.set(__self__, "vault_certificates", vault_certificates)

    @property
    @pulumi.getter(name="sourceVaults")
    def source_vaults(self) -> Sequence['outputs.StatefulNodeAzureSecretSourceVault']:
        return pulumi.get(self, "source_vaults")

    @property
    @pulumi.getter(name="vaultCertificates")
    def vault_certificates(self) -> Sequence['outputs.StatefulNodeAzureSecretVaultCertificate']:
        return pulumi.get(self, "vault_certificates")


@pulumi.output_type
class StatefulNodeAzureSecretSourceVault(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "resourceGroupName":
            suggest = "resource_group_name"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 resource_group_name: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resource_group_name", resource_group_name)

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

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


@pulumi.output_type
class StatefulNodeAzureSecretVaultCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateStore":
            suggest = "certificate_store"
        elif key == "certificateUrl":
            suggest = "certificate_url"

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureSecurity(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "confidentialOsDiskEncryption":
            suggest = "confidential_os_disk_encryption"
        elif key == "encryptionAtHost":
            suggest = "encryption_at_host"
        elif key == "secureBootEnabled":
            suggest = "secure_boot_enabled"
        elif key == "securityType":
            suggest = "security_type"
        elif key == "vtpmEnabled":
            suggest = "vtpm_enabled"

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

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

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

    def __init__(__self__, *,
                 confidential_os_disk_encryption: Optional[bool] = None,
                 encryption_at_host: Optional[bool] = None,
                 secure_boot_enabled: Optional[bool] = None,
                 security_type: Optional[str] = None,
                 vtpm_enabled: Optional[bool] = None):
        if confidential_os_disk_encryption is not None:
            pulumi.set(__self__, "confidential_os_disk_encryption", confidential_os_disk_encryption)
        if encryption_at_host is not None:
            pulumi.set(__self__, "encryption_at_host", encryption_at_host)
        if secure_boot_enabled is not None:
            pulumi.set(__self__, "secure_boot_enabled", secure_boot_enabled)
        if security_type is not None:
            pulumi.set(__self__, "security_type", security_type)
        if vtpm_enabled is not None:
            pulumi.set(__self__, "vtpm_enabled", vtpm_enabled)

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureSignal(dict):
    def __init__(__self__, *,
                 timeout: int,
                 type: str):
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "type", type)

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

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


@pulumi.output_type
class StatefulNodeAzureStrategy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fallbackToOnDemand":
            suggest = "fallback_to_on_demand"
        elif key == "availabilityVsCost":
            suggest = "availability_vs_cost"
        elif key == "capacityReservations":
            suggest = "capacity_reservations"
        elif key == "drainingTimeout":
            suggest = "draining_timeout"
        elif key == "odWindows":
            suggest = "od_windows"
        elif key == "optimizationWindows":
            suggest = "optimization_windows"
        elif key == "preferredLifeCycle":
            suggest = "preferred_life_cycle"
        elif key == "revertToSpot":
            suggest = "revert_to_spot"
        elif key == "vmAdmins":
            suggest = "vm_admins"

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

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

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

    def __init__(__self__, *,
                 fallback_to_on_demand: bool,
                 availability_vs_cost: Optional[int] = None,
                 capacity_reservations: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservation']] = None,
                 draining_timeout: Optional[int] = None,
                 od_windows: Optional[Sequence[str]] = None,
                 optimization_windows: Optional[Sequence[str]] = None,
                 preferred_life_cycle: Optional[str] = None,
                 revert_to_spot: Optional['outputs.StatefulNodeAzureStrategyRevertToSpot'] = None,
                 vm_admins: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
        if availability_vs_cost is not None:
            pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
        if capacity_reservations is not None:
            pulumi.set(__self__, "capacity_reservations", capacity_reservations)
        if draining_timeout is not None:
            pulumi.set(__self__, "draining_timeout", draining_timeout)
        if od_windows is not None:
            pulumi.set(__self__, "od_windows", od_windows)
        if optimization_windows is not None:
            pulumi.set(__self__, "optimization_windows", optimization_windows)
        if preferred_life_cycle is not None:
            pulumi.set(__self__, "preferred_life_cycle", preferred_life_cycle)
        if revert_to_spot is not None:
            pulumi.set(__self__, "revert_to_spot", revert_to_spot)
        if vm_admins is not None:
            pulumi.set(__self__, "vm_admins", vm_admins)

    @property
    @pulumi.getter(name="fallbackToOnDemand")
    def fallback_to_on_demand(self) -> bool:
        return pulumi.get(self, "fallback_to_on_demand")

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

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

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

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

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

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

    @property
    @pulumi.getter(name="revertToSpot")
    def revert_to_spot(self) -> Optional['outputs.StatefulNodeAzureStrategyRevertToSpot']:
        return pulumi.get(self, "revert_to_spot")

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


@pulumi.output_type
class StatefulNodeAzureStrategyCapacityReservation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "shouldUtilize":
            suggest = "should_utilize"
        elif key == "utilizationStrategy":
            suggest = "utilization_strategy"
        elif key == "capacityReservationGroups":
            suggest = "capacity_reservation_groups"

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

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

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

    def __init__(__self__, *,
                 should_utilize: bool,
                 utilization_strategy: str,
                 capacity_reservation_groups: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup']] = None):
        pulumi.set(__self__, "should_utilize", should_utilize)
        pulumi.set(__self__, "utilization_strategy", utilization_strategy)
        if capacity_reservation_groups is not None:
            pulumi.set(__self__, "capacity_reservation_groups", capacity_reservation_groups)

    @property
    @pulumi.getter(name="shouldUtilize")
    def should_utilize(self) -> bool:
        return pulumi.get(self, "should_utilize")

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

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


@pulumi.output_type
class StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "crgName":
            suggest = "crg_name"
        elif key == "crgResourceGroupName":
            suggest = "crg_resource_group_name"
        elif key == "crgShouldPrioritize":
            suggest = "crg_should_prioritize"

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

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

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

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

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

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

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


@pulumi.output_type
class StatefulNodeAzureStrategyRevertToSpot(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "performAt":
            suggest = "perform_at"

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

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

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

    def __init__(__self__, *,
                 perform_at: str):
        pulumi.set(__self__, "perform_at", perform_at)

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


@pulumi.output_type
class StatefulNodeAzureTag(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "tagKey":
            suggest = "tag_key"
        elif key == "tagValue":
            suggest = "tag_value"

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

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

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

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

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

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


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

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


@pulumi.output_type
class StatefulNodeAzureVmSizes(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "odSizes":
            suggest = "od_sizes"
        elif key == "spotSizes":
            suggest = "spot_sizes"
        elif key == "preferredSpotSizes":
            suggest = "preferred_spot_sizes"

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

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

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

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

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

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

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


