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,
        revertToSpot: {
            performAt: "timeWindow",
        },
        preferredLifeCycle: "od",
        capacityReservations: [{
            shouldUtilize: true,
            utilizationStrategy: "utilizeOverOD",
            capacityReservationGroups: [{
                crgName: "crg name",
                crgResourceGroupName: "resourceGroupName",
                crgShouldPrioritize: true,
            }],
        }],
    },
    os: "Linux",
    odSizes: [
        "standard_ds1_v2",
        "standard_ds2_v2",
    ],
    spotSizes: [
        "standard_ds1_v2",
        "standard_ds2_v2",
    ],
    preferredSpotSizes: ["standard_ds1_v2"],
    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",
        }],
    },
    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: "Standard",
        secureBootEnabled: false,
        vtpmEnabled: false,
    },
    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,
    }],
});

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=spotinst.StatefulNodeAzureStrategyArgs(
        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,
        revert_to_spot=spotinst.StatefulNodeAzureStrategyRevertToSpotArgs(
            perform_at="timeWindow",
        ),
        preferred_life_cycle="od",
        capacity_reservations=[spotinst.StatefulNodeAzureStrategyCapacityReservationArgs(
            should_utilize=True,
            utilization_strategy="utilizeOverOD",
            capacity_reservation_groups=[spotinst.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroupArgs(
                crg_name="crg name",
                crg_resource_group_name="resourceGroupName",
                crg_should_prioritize=True,
            )],
        )],
    ),
    os="Linux",
    od_sizes=[
        "standard_ds1_v2",
        "standard_ds2_v2",
    ],
    spot_sizes=[
        "standard_ds1_v2",
        "standard_ds2_v2",
    ],
    preferred_spot_sizes=["standard_ds1_v2"],
    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=[spotinst.StatefulNodeAzureBootDiagnosticArgs(
        is_enabled=True,
        storage_url="https://.blob.core.windows.net/test",
        type="unmanaged",
    )],
    data_disks=[
        spotinst.StatefulNodeAzureDataDiskArgs(
            size_gb=1,
            lun=1,
            type="Standard_LRS",
        ),
        spotinst.StatefulNodeAzureDataDiskArgs(
            size_gb=10,
            lun=2,
            type="Standard_LRS",
        ),
    ],
    extensions=[spotinst.StatefulNodeAzureExtensionArgs(
        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=spotinst.StatefulNodeAzureImageArgs(
        marketplace_images=[spotinst.StatefulNodeAzureImageMarketplaceImageArgs(
            publisher="Canonical",
            offer="UbuntuServer",
            sku="16.04-LTS",
            version="latest",
        )],
        custom_images=[spotinst.StatefulNodeAzureImageCustomImageArgs(
            custom_image_resource_group_name="resourceGroupName",
            name="imageName",
        )],
        galleries=[spotinst.StatefulNodeAzureImageGalleryArgs(
            gallery_resource_group_name="resourceGroupName",
            gallery_name="galleryName",
            image_name="imageName",
            version_name="1.1.0",
        )],
    ),
    load_balancers=[spotinst.StatefulNodeAzureLoadBalancerArgs(
        type="loadBalancer",
        resource_group_name="testResourceGroup",
        name="testLoadBalancer",
        sku="Standard",
        backend_pool_names=[
            "testBackendPool1",
            "testBackendPool2",
        ],
    )],
    login=spotinst.StatefulNodeAzureLoginArgs(
        user_name="admin",
        ssh_public_key="33a2s1f3g5a1df5g1ad3f2g1adfg56dfg==",
    ),
    managed_service_identities=[spotinst.StatefulNodeAzureManagedServiceIdentityArgs(
        name="mySI2",
        resource_group_name="myResourceGroup",
    )],
    network=spotinst.StatefulNodeAzureNetworkArgs(
        network_resource_group_name="subnetResourceGroup",
        virtual_network_name="vname",
        network_interfaces=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceArgs(
            is_primary=True,
            subnet_name="testSubnet",
            assign_public_ip=True,
            public_ip_sku="Standard",
            network_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroupArgs(
                network_resource_group_name="test",
                name="test",
            )],
            enable_ip_forwarding=True,
            private_ip_addresses=["172.23.4.20"],
            additional_ip_configurations=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfigurationArgs(
                name="test",
                private_ip_address_version="IPv4",
            )],
            public_ips=[spotinst.StatefulNodeAzureNetworkNetworkInterfacePublicIpArgs(
                network_resource_group_name="resourceGroup",
                name="test",
            )],
            application_security_groups=[spotinst.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroupArgs(
                network_resource_group_name="AsgResourceGroup",
                name="AsgName",
            )],
        )],
    ),
    os_disk=spotinst.StatefulNodeAzureOsDiskArgs(
        size_gb=30,
        type="Standard_LRS",
        caching="ReadOnly",
    ),
    secrets=[spotinst.StatefulNodeAzureSecretArgs(
        source_vaults=[spotinst.StatefulNodeAzureSecretSourceVaultArgs(
            name="string",
            resource_group_name="string",
        )],
        vault_certificates=[spotinst.StatefulNodeAzureSecretVaultCertificateArgs(
            certificate_url="string",
            certificate_store="string",
        )],
    )],
    security=spotinst.StatefulNodeAzureSecurityArgs(
        security_type="Standard",
        secure_boot_enabled=False,
        vtpm_enabled=False,
    ),
    tags=[spotinst.StatefulNodeAzureTagArgs(
        tag_key="Creator",
        tag_value="string",
    )],
    health=spotinst.StatefulNodeAzureHealthArgs(
        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=[
        spotinst.StatefulNodeAzureSchedulingTaskArgs(
            is_enabled=True,
            type="pause",
            cron_expression="44 10 * * *",
        ),
        spotinst.StatefulNodeAzureSchedulingTaskArgs(
            is_enabled=True,
            type="resume",
            cron_expression="48 10 * * *",
        ),
        spotinst.StatefulNodeAzureSchedulingTaskArgs(
            is_enabled=True,
            type="recycle",
            cron_expression="52 10 * * *",
        ),
    ],
    signals=[
        spotinst.StatefulNodeAzureSignalArgs(
            type="vmReady",
            timeout=20,
        ),
        spotinst.StatefulNodeAzureSignalArgs(
            type="vmReady",
            timeout=40,
        ),
    ],
    proximity_placement_groups=[spotinst.StatefulNodeAzureProximityPlacementGroupArgs(
        name="TestPPG",
        resource_group_name="TestResourceGroup",
    )],
    deletes=[spotinst.StatefulNodeAzureDeleteArgs(
        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,
    )])

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),
				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"),
			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"),
			},
			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.Map{
						"script": pulumi.Any("IyEvYmluL2Jhc2gKZWNobyAibmlyIiA+IC9ob29uaXIudHh0Cg=="),
					},
					PublicSettings: pulumi.Map{
						"fileUris": pulumi.Any{
							"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"),
					},
				},
			},
			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("Standard"),
				SecureBootEnabled: pulumi.Bool(false),
				VtpmEnabled:       pulumi.Bool(false),
			},
			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),
				},
			},
		})
		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,
            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",
        OdSizes = new[]
        {
            "standard_ds1_v2",
            "standard_ds2_v2",
        },
        SpotSizes = new[]
        {
            "standard_ds1_v2",
            "standard_ds2_v2",
        },
        PreferredSpotSizes = new[]
        {
            "standard_ds1_v2",
        },
        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", new[]
                    {
                        "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",
                },
            },
        },
        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 = "Standard",
            SecureBootEnabled = false,
            VtpmEnabled = false,
        },
        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,
            },
        },
    });

});

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.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)
                .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")
            .odSizes(            
                "standard_ds1_v2",
                "standard_ds2_v2")
            .spotSizes(            
                "standard_ds1_v2",
                "standard_ds2_v2")
            .preferredSpotSizes("standard_ds1_v2")
            .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")
                    .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("Standard")
                .secureBootEnabled(false)
                .vtpmEnabled(false)
                .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)
                .build())
            .build());

    }
}

resources:
  testStatefulNodeAzure:
    type: spotinst:StatefulNodeAzure
    name: test_stateful_node_azure
    properties:
      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
        revertToSpot:
          performAt: timeWindow
        preferredLifeCycle: od
        capacityReservations:
          - shouldUtilize: true
            utilizationStrategy: utilizeOverOD
            capacityReservationGroups:
              - crgName: crg name
                crgResourceGroupName: resourceGroupName
                crgShouldPrioritize: true
      os: Linux
      odSizes:
        - standard_ds1_v2
        - standard_ds2_v2
      spotSizes:
        - standard_ds1_v2
        - standard_ds2_v2
      preferredSpotSizes:
        - standard_ds1_v2
      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
      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: Standard
        secureBootEnabled: false
        vtpmEnabled: false
      tags:
        - tagKey: Creator
          tagValue: string
      health:
        healthCheckTypes:
          - vmState
        unhealthyDuration: 300
        gracePeriod: 120
        autoHealing: true
      shouldPersistOsDisk: false
      osDiskPersistenceMode: reattach
      shouldPersistDataDisks: true
      dataDisksPersistenceMode: reattach
      shouldPersistNetwork: true # --- SCHEDULING TASKS ----------------------------------------------
      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