import * as pulumi from "@pulumi/pulumi";
import * as spotinst from "@pulumi/spotinst";

const testStatefulNodeAzure = new spotinst.StatefulNodeAzure("test_stateful_node_azure", {
    name: "example_stateful_node_azure",
    region: "eastus",
    resourceGroupName: "spotinst-azure",
    description: "example_stateful_node_azure_description",
    strategy: {
        drainingTimeout: 30,
        fallbackToOnDemand: true,
        optimizationWindows: ["Tue:19:46-Tue:20:46"],
        odWindows: ["Wed:19:46-Wed:21:46"],
        availabilityVsCost: 100,
        vmAdmins: [
            "UbuntuUser",
            "TestUser",
        ],
        revertToSpot: {
            performAt: "timeWindow",
        },
        preferredLifeCycle: "od",
        capacityReservations: [{
            shouldUtilize: true,
            utilizationStrategy: "utilizeOverOD",
            capacityReservationGroups: [{
                crgName: "crg name",
                crgResourceGroupName: "resourceGroupName",
                crgShouldPrioritize: true,
            }],
        }],
    },
    os: "Linux",
    vmSizes: {
        odSizes: [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        spotSizes: [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        preferredSpotSizes: ["standard_ds1_v2"],
        excludedVmSizes: ["standard_ds2_v3"],
        spotSizeAttributes: {
            maxCpu: 16,
            minCpu: 2,
            maxMemory: 48,
            minMemory: 2,
            maxStorage: 1000,
            minStorage: 50,
        },
    },
    zones: [
        "1",
        "3",
    ],
    preferredZone: "1",
    customData: "",
    shutdownScript: "",
    userData: "",
    vmName: "VMName",
    vmNamePrefix: "VMNamePrefix",
    licenseType: "SLES_BYOS",
    bootDiagnostics: [{
        isEnabled: true,
        storageUrl: "https://.blob.core.windows.net/test",
        type: "unmanaged",
    }],
    dataDisks: [
        {
            sizeGb: 1,
            lun: 1,
            type: "Standard_LRS",
        },
        {
            sizeGb: 10,
            lun: 2,
            type: "Standard_LRS",
        },
    ],
    extensions: [{
        name: "extensionName",
        type: "customScript",
        publisher: "Microsoft.Azure.Extensions",
        apiVersion: "2.0",
        minorVersionAutoUpgrade: true,
        protectedSettings: {
            script: "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==",
        },
        publicSettings: {
            fileUris: "https://testspot/Azuretest.sh",
        },
    }],
    image: {
        marketplaceImages: [{
            publisher: "Canonical",
            offer: "UbuntuServer",
            sku: "16.04-LTS",
            version: "latest",
        }],
        customImages: [{
            customImageResourceGroupName: "resourceGroupName",
            name: "imageName",
        }],
        galleries: [{
            galleryResourceGroupName: "resourceGroupName",
            galleryName: "galleryName",
            imageName: "imageName",
            versionName: "1.1.0",
            spotAccountId: "act-123456",
        }],
    },
    loadBalancers: [{
        type: "loadBalancer",
        resourceGroupName: "testResourceGroup",
        name: "testLoadBalancer",
        sku: "Standard",
        backendPoolNames: [
            "testBackendPool1",
            "testBackendPool2",
        ],
    }],
    login: {
        userName: "admin",
        sshPublicKey: "33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
    },
    managedServiceIdentities: [{
        name: "mySI2",
        resourceGroupName: "myResourceGroup",
    }],
    network: {
        networkResourceGroupName: "subnetResourceGroup",
        virtualNetworkName: "vname",
        networkInterfaces: [{
            isPrimary: true,
            subnetName: "testSubnet",
            assignPublicIp: true,
            publicIpSku: "Standard",
            networkSecurityGroups: [{
                networkResourceGroupName: "test",
                name: "test",
            }],
            enableIpForwarding: true,
            privateIpAddresses: ["172.23.4.20"],
            additionalIpConfigurations: [{
                name: "test",
                privateIpAddressVersion: "IPv4",
            }],
            publicIps: [{
                networkResourceGroupName: "resourceGroup",
                name: "test",
            }],
            applicationSecurityGroups: [{
                networkResourceGroupName: "AsgResourceGroup",
                name: "AsgName",
            }],
        }],
    },
    osDisk: {
        sizeGb: 30,
        type: "Standard_LRS",
        caching: "ReadOnly",
    },
    secrets: [{
        sourceVaults: [{
            name: "string",
            resourceGroupName: "string",
        }],
        vaultCertificates: [{
            certificateUrl: "string",
            certificateStore: "string",
        }],
    }],
    security: {
        securityType: "ConfidentialVM",
        secureBootEnabled: true,
        vtpmEnabled: true,
        encryptionAtHost: false,
        confidentialOsDiskEncryption: true,
    },
    tags: [{
        tagKey: "Creator",
        tagValue: "string",
    }],
    health: {
        healthCheckTypes: ["vmState"],
        unhealthyDuration: 300,
        gracePeriod: 120,
        autoHealing: true,
    },
    shouldPersistOsDisk: false,
    osDiskPersistenceMode: "reattach",
    shouldPersistDataDisks: true,
    dataDisksPersistenceMode: "reattach",
    shouldPersistNetwork: true,
    schedulingTasks: [
        {
            isEnabled: true,
            type: "pause",
            cronExpression: "44 10 * * *",
        },
        {
            isEnabled: true,
            type: "resume",
            cronExpression: "48 10 * * *",
        },
        {
            isEnabled: true,
            type: "recycle",
            cronExpression: "52 10 * * *",
        },
    ],
    signals: [
        {
            type: "vmReady",
            timeout: 20,
        },
        {
            type: "vmReady",
            timeout: 40,
        },
    ],
    proximityPlacementGroups: [{
        name: "TestPPG",
        resourceGroupName: "TestResourceGroup",
    }],
    deletes: [{
        shouldTerminateVm: true,
        networkShouldDeallocate: true,
        networkTtlInHours: 0,
        diskShouldDeallocate: true,
        diskTtlInHours: 0,
        snapshotShouldDeallocate: true,
        snapshotTtlInHours: 0,
        publicIpShouldDeallocate: true,
        publicIpTtlInHours: 0,
        shouldDeregisterFromLb: true,
        shouldRevertToOd: false,
    }],
});

import pulumi
import pulumi_spotinst as spotinst

test_stateful_node_azure = spotinst.StatefulNodeAzure("test_stateful_node_azure",
    name="example_stateful_node_azure",
    region="eastus",
    resource_group_name="spotinst-azure",
    description="example_stateful_node_azure_description",
    strategy={
        "draining_timeout": 30,
        "fallback_to_on_demand": True,
        "optimization_windows": ["Tue:19:46-Tue:20:46"],
        "od_windows": ["Wed:19:46-Wed:21:46"],
        "availability_vs_cost": 100,
        "vm_admins": [
            "UbuntuUser",
            "TestUser",
        ],
        "revert_to_spot": {
            "perform_at": "timeWindow",
        },
        "preferred_life_cycle": "od",
        "capacity_reservations": [{
            "should_utilize": True,
            "utilization_strategy": "utilizeOverOD",
            "capacity_reservation_groups": [{
                "crg_name": "crg name",
                "crg_resource_group_name": "resourceGroupName",
                "crg_should_prioritize": True,
            }],
        }],
    },
    os="Linux",
    vm_sizes={
        "od_sizes": [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        "spot_sizes": [
            "standard_ds1_v2",
            "standard_ds2_v2",
        ],
        "preferred_spot_sizes": ["standard_ds1_v2"],
        "excluded_vm_sizes": ["standard_ds2_v3"],
        "spot_size_attributes": {
            "max_cpu": 16,
            "min_cpu": 2,
            "max_memory": 48,
            "min_memory": 2,
            "max_storage": 1000,
            "min_storage": 50,
        },
    },
    zones=[
        "1",
        "3",
    ],
    preferred_zone="1",
    custom_data="",
    shutdown_script="",
    user_data="",
    vm_name="VMName",
    vm_name_prefix="VMNamePrefix",
    license_type="SLES_BYOS",
    boot_diagnostics=[{
        "is_enabled": True,
        "storage_url": "https://.blob.core.windows.net/test",
        "type": "unmanaged",
    }],
    data_disks=[
        {
            "size_gb": 1,
            "lun": 1,
            "type": "Standard_LRS",
        },
        {
            "size_gb": 10,
            "lun": 2,
            "type": "Standard_LRS",
        },
    ],
    extensions=[{
        "name": "extensionName",
        "type": "customScript",
        "publisher": "Microsoft.Azure.Extensions",
        "api_version": "2.0",
        "minor_version_auto_upgrade": True,
        "protected_settings": {
            "script": "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==",
        },
        "public_settings": {
            "fileUris": "https://testspot/Azuretest.sh",
        },
    }],
    image={
        "marketplace_images": [{
            "publisher": "Canonical",
            "offer": "UbuntuServer",
            "sku": "16.04-LTS",
            "version": "latest",
        }],
        "custom_images": [{
            "custom_image_resource_group_name": "resourceGroupName",
            "name": "imageName",
        }],
        "galleries": [{
            "gallery_resource_group_name": "resourceGroupName",
            "gallery_name": "galleryName",
            "image_name": "imageName",
            "version_name": "1.1.0",
            "spot_account_id": "act-123456",
        }],
    },
    load_balancers=[{
        "type": "loadBalancer",
        "resource_group_name": "testResourceGroup",
        "name": "testLoadBalancer",
        "sku": "Standard",
        "backend_pool_names": [
            "testBackendPool1",
            "testBackendPool2",
        ],
    }],
    login={
        "user_name": "admin",
        "ssh_public_key": "33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
    },
    managed_service_identities=[{
        "name": "mySI2",
        "resource_group_name": "myResourceGroup",
    }],
    network={
        "network_resource_group_name": "subnetResourceGroup",
        "virtual_network_name": "vname",
        "network_interfaces": [{
            "is_primary": True,
            "subnet_name": "testSubnet",
            "assign_public_ip": True,
            "public_ip_sku": "Standard",
            "network_security_groups": [{
                "network_resource_group_name": "test",
                "name": "test",
            }],
            "enable_ip_forwarding": True,
            "private_ip_addresses": ["172.23.4.20"],
            "additional_ip_configurations": [{
                "name": "test",
                "private_ip_address_version": "IPv4",
            }],
            "public_ips": [{
                "network_resource_group_name": "resourceGroup",
                "name": "test",
            }],
            "application_security_groups": [{
                "network_resource_group_name": "AsgResourceGroup",
                "name": "AsgName",
            }],
        }],
    },
    os_disk={
        "size_gb": 30,
        "type": "Standard_LRS",
        "caching": "ReadOnly",
    },
    secrets=[{
        "source_vaults": [{
            "name": "string",
            "resource_group_name": "string",
        }],
        "vault_certificates": [{
            "certificate_url": "string",
            "certificate_store": "string",
        }],
    }],
    security={
        "security_type": "ConfidentialVM",
        "secure_boot_enabled": True,
        "vtpm_enabled": True,
        "encryption_at_host": False,
        "confidential_os_disk_encryption": True,
    },
    tags=[{
        "tag_key": "Creator",
        "tag_value": "string",
    }],
    health={
        "health_check_types": ["vmState"],
        "unhealthy_duration": 300,
        "grace_period": 120,
        "auto_healing": True,
    },
    should_persist_os_disk=False,
    os_disk_persistence_mode="reattach",
    should_persist_data_disks=True,
    data_disks_persistence_mode="reattach",
    should_persist_network=True,
    scheduling_tasks=[
        {
            "is_enabled": True,
            "type": "pause",
            "cron_expression": "44 10 * * *",
        },
        {
            "is_enabled": True,
            "type": "resume",
            "cron_expression": "48 10 * * *",
        },
        {
            "is_enabled": True,
            "type": "recycle",
            "cron_expression": "52 10 * * *",
        },
    ],
    signals=[
        {
            "type": "vmReady",
            "timeout": 20,
        },
        {
            "type": "vmReady",
            "timeout": 40,
        },
    ],
    proximity_placement_groups=[{
        "name": "TestPPG",
        "resource_group_name": "TestResourceGroup",
    }],
    deletes=[{
        "should_terminate_vm": True,
        "network_should_deallocate": True,
        "network_ttl_in_hours": 0,
        "disk_should_deallocate": True,
        "disk_ttl_in_hours": 0,
        "snapshot_should_deallocate": True,
        "snapshot_ttl_in_hours": 0,
        "public_ip_should_deallocate": True,
        "public_ip_ttl_in_hours": 0,
        "should_deregister_from_lb": True,
        "should_revert_to_od": False,
    }])

package main

import (
	"github.com/pulumi/pulumi-spotinst/sdk/v3/go/spotinst"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := spotinst.NewStatefulNodeAzure(ctx, "test_stateful_node_azure", &spotinst.StatefulNodeAzureArgs{
			Name:              pulumi.String("example_stateful_node_azure"),
			Region:            pulumi.String("eastus"),
			ResourceGroupName: pulumi.String("spotinst-azure"),
			Description:       pulumi.String("example_stateful_node_azure_description"),
			Strategy: &spotinst.StatefulNodeAzureStrategyArgs{
				DrainingTimeout:    pulumi.Int(30),
				FallbackToOnDemand: pulumi.Bool(true),
				OptimizationWindows: pulumi.StringArray{
					pulumi.String("Tue:19:46-Tue:20:46"),
				},
				OdWindows: pulumi.StringArray{
					pulumi.String("Wed:19:46-Wed:21:46"),
				},
				AvailabilityVsCost: pulumi.Int(100),
				VmAdmins: pulumi.StringArray{
					pulumi.String("UbuntuUser"),
					pulumi.String("TestUser"),
				},
				RevertToSpot: &spotinst.StatefulNodeAzureStrategyRevertToSpotArgs{
					PerformAt: pulumi.String("timeWindow"),
				},
				PreferredLifeCycle: pulumi.String("od"),
				CapacityReservations: spotinst.StatefulNodeAzureStrategyCapacityReservationArray{
					&spotinst.StatefulNodeAzureStrategyCapacityReservationArgs{
						ShouldUtilize:       pulumi.Bool(true),
						UtilizationStrategy: pulumi.String("utilizeOverOD"),
						CapacityReservationGroups: spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArray{
							&spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs{
								CrgName:              pulumi.String("crg name"),
								CrgResourceGroupName: pulumi.String("resourceGroupName"),
								CrgShouldPrioritize:  pulumi.Bool(true),
							},
						},
					},
				},
			},
			Os: pulumi.String("Linux"),
			VmSizes: &spotinst.StatefulNodeAzureVmSizesArgs{
				OdSizes: pulumi.StringArray{
					pulumi.String("standard_ds1_v2"),
					pulumi.String("standard_ds2_v2"),
				},
				SpotSizes: pulumi.StringArray{
					pulumi.String("standard_ds1_v2"),
					pulumi.String("standard_ds2_v2"),
				},
				PreferredSpotSizes: pulumi.StringArray{
					pulumi.String("standard_ds1_v2"),
				},
				ExcludedVmSizes: pulumi.StringArray{
					pulumi.String("standard_ds2_v3"),
				},
				SpotSizeAttributes: &spotinst.StatefulNodeAzureVmSizesSpotSizeAttributesArgs{
					MaxCpu:     pulumi.Int(16),
					MinCpu:     pulumi.Int(2),
					MaxMemory:  pulumi.Int(48),
					MinMemory:  pulumi.Int(2),
					MaxStorage: pulumi.Int(1000),
					MinStorage: pulumi.Int(50),
				},
			},
			Zones: pulumi.StringArray{
				pulumi.String("1"),
				pulumi.String("3"),
			},
			PreferredZone:  pulumi.String("1"),
			CustomData:     pulumi.String(""),
			ShutdownScript: pulumi.String(""),
			UserData:       pulumi.String(""),
			VmName:         pulumi.String("VMName"),
			VmNamePrefix:   pulumi.String("VMNamePrefix"),
			LicenseType:    pulumi.String("SLES_BYOS"),
			BootDiagnostics: spotinst.StatefulNodeAzureBootDiagnosticArray{
				&spotinst.StatefulNodeAzureBootDiagnosticArgs{
					IsEnabled:  pulumi.Bool(true),
					StorageUrl: pulumi.String("https://.blob.core.windows.net/test"),
					Type:       pulumi.String("unmanaged"),
				},
			},
			DataDisks: spotinst.StatefulNodeAzureDataDiskArray{
				&spotinst.StatefulNodeAzureDataDiskArgs{
					SizeGb: pulumi.Int(1),
					Lun:    pulumi.Int(1),
					Type:   pulumi.String("Standard_LRS"),
				},
				&spotinst.StatefulNodeAzureDataDiskArgs{
					SizeGb: pulumi.Int(10),
					Lun:    pulumi.Int(2),
					Type:   pulumi.String("Standard_LRS"),
				},
			},
			Extensions: spotinst.StatefulNodeAzureExtensionArray{
				&spotinst.StatefulNodeAzureExtensionArgs{
					Name:                    pulumi.String("extensionName"),
					Type:                    pulumi.String("customScript"),
					Publisher:               pulumi.String("Microsoft.Azure.Extensions"),
					ApiVersion:              pulumi.String("2.0"),
					MinorVersionAutoUpgrade: pulumi.Bool(true),
					ProtectedSettings: pulumi.StringMap{
						"script": pulumi.String("IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg=="),
					},
					PublicSettings: pulumi.StringMap{
						"fileUris": pulumi.String("https://testspot/Azuretest.sh"),
					},
				},
			},
			Image: &spotinst.StatefulNodeAzureImageArgs{
				MarketplaceImages: spotinst.StatefulNodeAzureImageMarketplaceImageArray{
					&spotinst.StatefulNodeAzureImageMarketplaceImageArgs{
						Publisher: pulumi.String("Canonical"),
						Offer:     pulumi.String("UbuntuServer"),
						Sku:       pulumi.String("16.04-LTS"),
						Version:   pulumi.String("latest"),
					},
				},
				CustomImages: spotinst.StatefulNodeAzureImageCustomImageArray{
					&spotinst.StatefulNodeAzureImageCustomImageArgs{
						CustomImageResourceGroupName: pulumi.String("resourceGroupName"),
						Name:                         pulumi.String("imageName"),
					},
				},
				Galleries: spotinst.StatefulNodeAzureImageGalleryArray{
					&spotinst.StatefulNodeAzureImageGalleryArgs{
						GalleryResourceGroupName: pulumi.String("resourceGroupName"),
						GalleryName:              pulumi.String("galleryName"),
						ImageName:                pulumi.String("imageName"),
						VersionName:              pulumi.String("1.1.0"),
						SpotAccountId:            pulumi.String("act-123456"),
					},
				},
			},
			LoadBalancers: spotinst.StatefulNodeAzureLoadBalancerArray{
				&spotinst.StatefulNodeAzureLoadBalancerArgs{
					Type:              pulumi.String("loadBalancer"),
					ResourceGroupName: pulumi.String("testResourceGroup"),
					Name:              pulumi.String("testLoadBalancer"),
					Sku:               pulumi.String("Standard"),
					BackendPoolNames: pulumi.StringArray{
						pulumi.String("testBackendPool1"),
						pulumi.String("testBackendPool2"),
					},
				},
			},
			Login: &spotinst.StatefulNodeAzureLoginArgs{
				UserName:     pulumi.String("admin"),
				SshPublicKey: pulumi.String("33a2s1f3g5a1df5g1ad3f2g1adfg56dfg=="),
			},
			ManagedServiceIdentities: spotinst.StatefulNodeAzureManagedServiceIdentityArray{
				&spotinst.StatefulNodeAzureManagedServiceIdentityArgs{
					Name:              pulumi.String("mySI2"),
					ResourceGroupName: pulumi.String("myResourceGroup"),
				},
			},
			Network: &spotinst.StatefulNodeAzureNetworkArgs{
				NetworkResourceGroupName: pulumi.String("subnetResourceGroup"),
				VirtualNetworkName:       pulumi.String("vname"),
				NetworkInterfaces: spotinst.StatefulNodeAzureNetworkNetworkInterfaceArray{
					&spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs{
						IsPrimary:      pulumi.Bool(true),
						SubnetName:     pulumi.String("testSubnet"),
						AssignPublicIp: pulumi.Bool(true),
						PublicIpSku:    pulumi.String("Standard"),
						NetworkSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArray{
							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs{
								NetworkResourceGroupName: pulumi.String("test"),
								Name:                     pulumi.String("test"),
							},
						},
						EnableIpForwarding: pulumi.Bool(true),
						PrivateIpAddresses: pulumi.StringArray{
							pulumi.String("172.23.4.20"),
						},
						AdditionalIpConfigurations: spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArray{
							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs{
								Name:                    pulumi.String("test"),
								PrivateIpAddressVersion: pulumi.String("IPv4"),
							},
						},
						PublicIps: spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArray{
							&spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs{
								NetworkResourceGroupName: pulumi.String("resourceGroup"),
								Name:                     pulumi.String("test"),
							},
						},
						ApplicationSecurityGroups: spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArray{
							&spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs{
								NetworkResourceGroupName: pulumi.String("AsgResourceGroup"),
								Name:                     pulumi.String("AsgName"),
							},
						},
					},
				},
			},
			OsDisk: &spotinst.StatefulNodeAzureOsDiskArgs{
				SizeGb:  pulumi.Int(30),
				Type:    pulumi.String("Standard_LRS"),
				Caching: pulumi.String("ReadOnly"),
			},
			Secrets: spotinst.StatefulNodeAzureSecretArray{
				&spotinst.StatefulNodeAzureSecretArgs{
					SourceVaults: spotinst.StatefulNodeAzureSecretSourceVaultArray{
						&spotinst.StatefulNodeAzureSecretSourceVaultArgs{
							Name:              pulumi.String("string"),
							ResourceGroupName: pulumi.String("string"),
						},
					},
					VaultCertificates: spotinst.StatefulNodeAzureSecretVaultCertificateArray{
						&spotinst.StatefulNodeAzureSecretVaultCertificateArgs{
							CertificateUrl:   pulumi.String("string"),
							CertificateStore: pulumi.String("string"),
						},
					},
				},
			},
			Security: &spotinst.StatefulNodeAzureSecurityArgs{
				SecurityType:                 pulumi.String("ConfidentialVM"),
				SecureBootEnabled:            pulumi.Bool(true),
				VtpmEnabled:                  pulumi.Bool(true),
				EncryptionAtHost:             pulumi.Bool(false),
				ConfidentialOsDiskEncryption: pulumi.Bool(true),
			},
			Tags: spotinst.StatefulNodeAzureTagArray{
				&spotinst.StatefulNodeAzureTagArgs{
					TagKey:   pulumi.String("Creator"),
					TagValue: pulumi.String("string"),
				},
			},
			Health: &spotinst.StatefulNodeAzureHealthArgs{
				HealthCheckTypes: pulumi.StringArray{
					pulumi.String("vmState"),
				},
				UnhealthyDuration: pulumi.Int(300),
				GracePeriod:       pulumi.Int(120),
				AutoHealing:       pulumi.Bool(true),
			},
			ShouldPersistOsDisk:      pulumi.Bool(false),
			OsDiskPersistenceMode:    pulumi.String("reattach"),
			ShouldPersistDataDisks:   pulumi.Bool(true),
			DataDisksPersistenceMode: pulumi.String("reattach"),
			ShouldPersistNetwork:     pulumi.Bool(true),
			SchedulingTasks: spotinst.StatefulNodeAzureSchedulingTaskArray{
				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
					IsEnabled:      pulumi.Bool(true),
					Type:           pulumi.String("pause"),
					CronExpression: pulumi.String("44 10 * * *"),
				},
				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
					IsEnabled:      pulumi.Bool(true),
					Type:           pulumi.String("resume"),
					CronExpression: pulumi.String("48 10 * * *"),
				},
				&spotinst.StatefulNodeAzureSchedulingTaskArgs{
					IsEnabled:      pulumi.Bool(true),
					Type:           pulumi.String("recycle"),
					CronExpression: pulumi.String("52 10 * * *"),
				},
			},
			Signals: spotinst.StatefulNodeAzureSignalArray{
				&spotinst.StatefulNodeAzureSignalArgs{
					Type:    pulumi.String("vmReady"),
					Timeout: pulumi.Int(20),
				},
				&spotinst.StatefulNodeAzureSignalArgs{
					Type:    pulumi.String("vmReady"),
					Timeout: pulumi.Int(40),
				},
			},
			ProximityPlacementGroups: spotinst.StatefulNodeAzureProximityPlacementGroupArray{
				&spotinst.StatefulNodeAzureProximityPlacementGroupArgs{
					Name:              pulumi.String("TestPPG"),
					ResourceGroupName: pulumi.String("TestResourceGroup"),
				},
			},
			Deletes: spotinst.StatefulNodeAzureDeleteArray{
				&spotinst.StatefulNodeAzureDeleteArgs{
					ShouldTerminateVm:        pulumi.Bool(true),
					NetworkShouldDeallocate:  pulumi.Bool(true),
					NetworkTtlInHours:        pulumi.Int(0),
					DiskShouldDeallocate:     pulumi.Bool(true),
					DiskTtlInHours:           pulumi.Int(0),
					SnapshotShouldDeallocate: pulumi.Bool(true),
					SnapshotTtlInHours:       pulumi.Int(0),
					PublicIpShouldDeallocate: pulumi.Bool(true),
					PublicIpTtlInHours:       pulumi.Int(0),
					ShouldDeregisterFromLb:   pulumi.Bool(true),
					ShouldRevertToOd:         pulumi.Bool(false),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using SpotInst = Pulumi.SpotInst;

return await Deployment.RunAsync(() => 
{
    var testStatefulNodeAzure = new SpotInst.StatefulNodeAzure("test_stateful_node_azure", new()
    {
        Name = "example_stateful_node_azure",
        Region = "eastus",
        ResourceGroupName = "spotinst-azure",
        Description = "example_stateful_node_azure_description",
        Strategy = new SpotInst.Inputs.StatefulNodeAzureStrategyArgs
        {
            DrainingTimeout = 30,
            FallbackToOnDemand = true,
            OptimizationWindows = new[]
            {
                "Tue:19:46-Tue:20:46",
            },
            OdWindows = new[]
            {
                "Wed:19:46-Wed:21:46",
            },
            AvailabilityVsCost = 100,
            VmAdmins = new[]
            {
                "UbuntuUser",
                "TestUser",
            },
            RevertToSpot = new SpotInst.Inputs.StatefulNodeAzureStrategyRevertToSpotArgs
            {
                PerformAt = "timeWindow",
            },
            PreferredLifeCycle = "od",
            CapacityReservations = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationArgs
                {
                    ShouldUtilize = true,
                    UtilizationStrategy = "utilizeOverOD",
                    CapacityReservationGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs
                        {
                            CrgName = "crg name",
                            CrgResourceGroupName = "resourceGroupName",
                            CrgShouldPrioritize = true,
                        },
                    },
                },
            },
        },
        Os = "Linux",
        VmSizes = new SpotInst.Inputs.StatefulNodeAzureVmSizesArgs
        {
            OdSizes = new[]
            {
                "standard_ds1_v2",
                "standard_ds2_v2",
            },
            SpotSizes = new[]
            {
                "standard_ds1_v2",
                "standard_ds2_v2",
            },
            PreferredSpotSizes = new[]
            {
                "standard_ds1_v2",
            },
            ExcludedVmSizes = new[]
            {
                "standard_ds2_v3",
            },
            SpotSizeAttributes = new SpotInst.Inputs.StatefulNodeAzureVmSizesSpotSizeAttributesArgs
            {
                MaxCpu = 16,
                MinCpu = 2,
                MaxMemory = 48,
                MinMemory = 2,
                MaxStorage = 1000,
                MinStorage = 50,
            },
        },
        Zones = new[]
        {
            "1",
            "3",
        },
        PreferredZone = "1",
        CustomData = "",
        ShutdownScript = "",
        UserData = "",
        VmName = "VMName",
        VmNamePrefix = "VMNamePrefix",
        LicenseType = "SLES_BYOS",
        BootDiagnostics = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureBootDiagnosticArgs
            {
                IsEnabled = true,
                StorageUrl = "https://.blob.core.windows.net/test",
                Type = "unmanaged",
            },
        },
        DataDisks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureDataDiskArgs
            {
                SizeGb = 1,
                Lun = 1,
                Type = "Standard_LRS",
            },
            new SpotInst.Inputs.StatefulNodeAzureDataDiskArgs
            {
                SizeGb = 10,
                Lun = 2,
                Type = "Standard_LRS",
            },
        },
        Extensions = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureExtensionArgs
            {
                Name = "extensionName",
                Type = "customScript",
                Publisher = "Microsoft.Azure.Extensions",
                ApiVersion = "2.0",
                MinorVersionAutoUpgrade = true,
                ProtectedSettings = 
                {
                    { "script", "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg==" },
                },
                PublicSettings = 
                {
                    { "fileUris", "https://testspot/Azuretest.sh" },
                },
            },
        },
        Image = new SpotInst.Inputs.StatefulNodeAzureImageArgs
        {
            MarketplaceImages = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageMarketplaceImageArgs
                {
                    Publisher = "Canonical",
                    Offer = "UbuntuServer",
                    Sku = "16.04-LTS",
                    Version = "latest",
                },
            },
            CustomImages = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageCustomImageArgs
                {
                    CustomImageResourceGroupName = "resourceGroupName",
                    Name = "imageName",
                },
            },
            Galleries = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureImageGalleryArgs
                {
                    GalleryResourceGroupName = "resourceGroupName",
                    GalleryName = "galleryName",
                    ImageName = "imageName",
                    VersionName = "1.1.0",
                    SpotAccountId = "act-123456",
                },
            },
        },
        LoadBalancers = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureLoadBalancerArgs
            {
                Type = "loadBalancer",
                ResourceGroupName = "testResourceGroup",
                Name = "testLoadBalancer",
                Sku = "Standard",
                BackendPoolNames = new[]
                {
                    "testBackendPool1",
                    "testBackendPool2",
                },
            },
        },
        Login = new SpotInst.Inputs.StatefulNodeAzureLoginArgs
        {
            UserName = "admin",
            SshPublicKey = "33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
        },
        ManagedServiceIdentities = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureManagedServiceIdentityArgs
            {
                Name = "mySI2",
                ResourceGroupName = "myResourceGroup",
            },
        },
        Network = new SpotInst.Inputs.StatefulNodeAzureNetworkArgs
        {
            NetworkResourceGroupName = "subnetResourceGroup",
            VirtualNetworkName = "vname",
            NetworkInterfaces = new[]
            {
                new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceArgs
                {
                    IsPrimary = true,
                    SubnetName = "testSubnet",
                    AssignPublicIp = true,
                    PublicIpSku = "Standard",
                    NetworkSecurityGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs
                        {
                            NetworkResourceGroupName = "test",
                            Name = "test",
                        },
                    },
                    EnableIpForwarding = true,
                    PrivateIpAddresses = new[]
                    {
                        "172.23.4.20",
                    },
                    AdditionalIpConfigurations = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs
                        {
                            Name = "test",
                            PrivateIpAddressVersion = "IPv4",
                        },
                    },
                    PublicIps = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs
                        {
                            NetworkResourceGroupName = "resourceGroup",
                            Name = "test",
                        },
                    },
                    ApplicationSecurityGroups = new[]
                    {
                        new SpotInst.Inputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs
                        {
                            NetworkResourceGroupName = "AsgResourceGroup",
                            Name = "AsgName",
                        },
                    },
                },
            },
        },
        OsDisk = new SpotInst.Inputs.StatefulNodeAzureOsDiskArgs
        {
            SizeGb = 30,
            Type = "Standard_LRS",
            Caching = "ReadOnly",
        },
        Secrets = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSecretArgs
            {
                SourceVaults = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureSecretSourceVaultArgs
                    {
                        Name = "string",
                        ResourceGroupName = "string",
                    },
                },
                VaultCertificates = new[]
                {
                    new SpotInst.Inputs.StatefulNodeAzureSecretVaultCertificateArgs
                    {
                        CertificateUrl = "string",
                        CertificateStore = "string",
                    },
                },
            },
        },
        Security = new SpotInst.Inputs.StatefulNodeAzureSecurityArgs
        {
            SecurityType = "ConfidentialVM",
            SecureBootEnabled = true,
            VtpmEnabled = true,
            EncryptionAtHost = false,
            ConfidentialOsDiskEncryption = true,
        },
        Tags = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureTagArgs
            {
                TagKey = "Creator",
                TagValue = "string",
            },
        },
        Health = new SpotInst.Inputs.StatefulNodeAzureHealthArgs
        {
            HealthCheckTypes = new[]
            {
                "vmState",
            },
            UnhealthyDuration = 300,
            GracePeriod = 120,
            AutoHealing = true,
        },
        ShouldPersistOsDisk = false,
        OsDiskPersistenceMode = "reattach",
        ShouldPersistDataDisks = true,
        DataDisksPersistenceMode = "reattach",
        ShouldPersistNetwork = true,
        SchedulingTasks = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
            {
                IsEnabled = true,
                Type = "pause",
                CronExpression = "44 10 * * *",
            },
            new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
            {
                IsEnabled = true,
                Type = "resume",
                CronExpression = "48 10 * * *",
            },
            new SpotInst.Inputs.StatefulNodeAzureSchedulingTaskArgs
            {
                IsEnabled = true,
                Type = "recycle",
                CronExpression = "52 10 * * *",
            },
        },
        Signals = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureSignalArgs
            {
                Type = "vmReady",
                Timeout = 20,
            },
            new SpotInst.Inputs.StatefulNodeAzureSignalArgs
            {
                Type = "vmReady",
                Timeout = 40,
            },
        },
        ProximityPlacementGroups = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureProximityPlacementGroupArgs
            {
                Name = "TestPPG",
                ResourceGroupName = "TestResourceGroup",
            },
        },
        Deletes = new[]
        {
            new SpotInst.Inputs.StatefulNodeAzureDeleteArgs
            {
                ShouldTerminateVm = true,
                NetworkShouldDeallocate = true,
                NetworkTtlInHours = 0,
                DiskShouldDeallocate = true,
                DiskTtlInHours = 0,
                SnapshotShouldDeallocate = true,
                SnapshotTtlInHours = 0,
                PublicIpShouldDeallocate = true,
                PublicIpTtlInHours = 0,
                ShouldDeregisterFromLb = true,
                ShouldRevertToOd = false,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.spotinst.StatefulNodeAzure;
import com.pulumi.spotinst.StatefulNodeAzureArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureStrategyArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureStrategyRevertToSpotArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureVmSizesArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureVmSizesSpotSizeAttributesArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureBootDiagnosticArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureDataDiskArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureExtensionArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureImageArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureLoadBalancerArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureLoginArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureManagedServiceIdentityArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureNetworkArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureOsDiskArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureSecretArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureSecurityArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureTagArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureHealthArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureSchedulingTaskArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureSignalArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureProximityPlacementGroupArgs;
import com.pulumi.spotinst.inputs.StatefulNodeAzureDeleteArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var testStatefulNodeAzure = new StatefulNodeAzure("testStatefulNodeAzure", StatefulNodeAzureArgs.builder()
            .name("example_stateful_node_azure")
            .region("eastus")
            .resourceGroupName("spotinst-azure")
            .description("example_stateful_node_azure_description")
            .strategy(StatefulNodeAzureStrategyArgs.builder()
                .drainingTimeout(30)
                .fallbackToOnDemand(true)
                .optimizationWindows("Tue:19:46-Tue:20:46")
                .odWindows("Wed:19:46-Wed:21:46")
                .availabilityVsCost(100)
                .vmAdmins(                
                    "UbuntuUser",
                    "TestUser")
                .revertToSpot(StatefulNodeAzureStrategyRevertToSpotArgs.builder()
                    .performAt("timeWindow")
                    .build())
                .preferredLifeCycle("od")
                .capacityReservations(StatefulNodeAzureStrategyCapacityReservationArgs.builder()
                    .shouldUtilize(true)
                    .utilizationStrategy("utilizeOverOD")
                    .capacityReservationGroups(StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs.builder()
                        .crgName("crg name")
                        .crgResourceGroupName("resourceGroupName")
                        .crgShouldPrioritize(true)
                        .build())
                    .build())
                .build())
            .os("Linux")
            .vmSizes(StatefulNodeAzureVmSizesArgs.builder()
                .odSizes(                
                    "standard_ds1_v2",
                    "standard_ds2_v2")
                .spotSizes(                
                    "standard_ds1_v2",
                    "standard_ds2_v2")
                .preferredSpotSizes("standard_ds1_v2")
                .excludedVmSizes("standard_ds2_v3")
                .spotSizeAttributes(StatefulNodeAzureVmSizesSpotSizeAttributesArgs.builder()
                    .maxCpu(16)
                    .minCpu(2)
                    .maxMemory(48)
                    .minMemory(2)
                    .maxStorage(1000)
                    .minStorage(50)
                    .build())
                .build())
            .zones(            
                "1",
                "3")
            .preferredZone("1")
            .customData("")
            .shutdownScript("")
            .userData("")
            .vmName("VMName")
            .vmNamePrefix("VMNamePrefix")
            .licenseType("SLES_BYOS")
            .bootDiagnostics(StatefulNodeAzureBootDiagnosticArgs.builder()
                .isEnabled(true)
                .storageUrl("https://.blob.core.windows.net/test")
                .type("unmanaged")
                .build())
            .dataDisks(            
                StatefulNodeAzureDataDiskArgs.builder()
                    .sizeGb(1)
                    .lun(1)
                    .type("Standard_LRS")
                    .build(),
                StatefulNodeAzureDataDiskArgs.builder()
                    .sizeGb(10)
                    .lun(2)
                    .type("Standard_LRS")
                    .build())
            .extensions(StatefulNodeAzureExtensionArgs.builder()
                .name("extensionName")
                .type("customScript")
                .publisher("Microsoft.Azure.Extensions")
                .apiVersion("2.0")
                .minorVersionAutoUpgrade(true)
                .protectedSettings(Map.of("script", "IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg=="))
                .publicSettings(Map.of("fileUris", "https://testspot/Azuretest.sh"))
                .build())
            .image(StatefulNodeAzureImageArgs.builder()
                .marketplaceImages(StatefulNodeAzureImageMarketplaceImageArgs.builder()
                    .publisher("Canonical")
                    .offer("UbuntuServer")
                    .sku("16.04-LTS")
                    .version("latest")
                    .build())
                .customImages(StatefulNodeAzureImageCustomImageArgs.builder()
                    .customImageResourceGroupName("resourceGroupName")
                    .name("imageName")
                    .build())
                .galleries(StatefulNodeAzureImageGalleryArgs.builder()
                    .galleryResourceGroupName("resourceGroupName")
                    .galleryName("galleryName")
                    .imageName("imageName")
                    .versionName("1.1.0")
                    .spotAccountId("act-123456")
                    .build())
                .build())
            .loadBalancers(StatefulNodeAzureLoadBalancerArgs.builder()
                .type("loadBalancer")
                .resourceGroupName("testResourceGroup")
                .name("testLoadBalancer")
                .sku("Standard")
                .backendPoolNames(                
                    "testBackendPool1",
                    "testBackendPool2")
                .build())
            .login(StatefulNodeAzureLoginArgs.builder()
                .userName("admin")
                .sshPublicKey("33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==")
                .build())
            .managedServiceIdentities(StatefulNodeAzureManagedServiceIdentityArgs.builder()
                .name("mySI2")
                .resourceGroupName("myResourceGroup")
                .build())
            .network(StatefulNodeAzureNetworkArgs.builder()
                .networkResourceGroupName("subnetResourceGroup")
                .virtualNetworkName("vname")
                .networkInterfaces(StatefulNodeAzureNetworkNetworkInterfaceArgs.builder()
                    .isPrimary(true)
                    .subnetName("testSubnet")
                    .assignPublicIp(true)
                    .publicIpSku("Standard")
                    .networkSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs.builder()
                        .networkResourceGroupName("test")
                        .name("test")
                        .build())
                    .enableIpForwarding(true)
                    .privateIpAddresses("172.23.4.20")
                    .additionalIpConfigurations(StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs.builder()
                        .name("test")
                        .privateIpAddressVersion("IPv4")
                        .build())
                    .publicIps(StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs.builder()
                        .networkResourceGroupName("resourceGroup")
                        .name("test")
                        .build())
                    .applicationSecurityGroups(StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs.builder()
                        .networkResourceGroupName("AsgResourceGroup")
                        .name("AsgName")
                        .build())
                    .build())
                .build())
            .osDisk(StatefulNodeAzureOsDiskArgs.builder()
                .sizeGb(30)
                .type("Standard_LRS")
                .caching("ReadOnly")
                .build())
            .secrets(StatefulNodeAzureSecretArgs.builder()
                .sourceVaults(StatefulNodeAzureSecretSourceVaultArgs.builder()
                    .name("string")
                    .resourceGroupName("string")
                    .build())
                .vaultCertificates(StatefulNodeAzureSecretVaultCertificateArgs.builder()
                    .certificateUrl("string")
                    .certificateStore("string")
                    .build())
                .build())
            .security(StatefulNodeAzureSecurityArgs.builder()
                .securityType("ConfidentialVM")
                .secureBootEnabled(true)
                .vtpmEnabled(true)
                .encryptionAtHost(false)
                .confidentialOsDiskEncryption(true)
                .build())
            .tags(StatefulNodeAzureTagArgs.builder()
                .tagKey("Creator")
                .tagValue("string")
                .build())
            .health(StatefulNodeAzureHealthArgs.builder()
                .healthCheckTypes("vmState")
                .unhealthyDuration(300)
                .gracePeriod(120)
                .autoHealing(true)
                .build())
            .shouldPersistOsDisk(false)
            .osDiskPersistenceMode("reattach")
            .shouldPersistDataDisks(true)
            .dataDisksPersistenceMode("reattach")
            .shouldPersistNetwork(true)
            .schedulingTasks(            
                StatefulNodeAzureSchedulingTaskArgs.builder()
                    .isEnabled(true)
                    .type("pause")
                    .cronExpression("44 10 * * *")
                    .build(),
                StatefulNodeAzureSchedulingTaskArgs.builder()
                    .isEnabled(true)
                    .type("resume")
                    .cronExpression("48 10 * * *")
                    .build(),
                StatefulNodeAzureSchedulingTaskArgs.builder()
                    .isEnabled(true)
                    .type("recycle")
                    .cronExpression("52 10 * * *")
                    .build())
            .signals(            
                StatefulNodeAzureSignalArgs.builder()
                    .type("vmReady")
                    .timeout(20)
                    .build(),
                StatefulNodeAzureSignalArgs.builder()
                    .type("vmReady")
                    .timeout(40)
                    .build())
            .proximityPlacementGroups(StatefulNodeAzureProximityPlacementGroupArgs.builder()
                .name("TestPPG")
                .resourceGroupName("TestResourceGroup")
                .build())
            .deletes(StatefulNodeAzureDeleteArgs.builder()
                .shouldTerminateVm(true)
                .networkShouldDeallocate(true)
                .networkTtlInHours(0)
                .diskShouldDeallocate(true)
                .diskTtlInHours(0)
                .snapshotShouldDeallocate(true)
                .snapshotTtlInHours(0)
                .publicIpShouldDeallocate(true)
                .publicIpTtlInHours(0)
                .shouldDeregisterFromLb(true)
                .shouldRevertToOd(false)
                .build())
            .build());

    }
}