octopusdeploy.DeploymentProcess

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

// basic deployment process with 2 run a script steps
const example = new octopusdeploy.DeploymentProcess("example", {
    projectId: "Projects-123",
    steps: [
        {
            condition: "Success",
            name: "Hello world (using PowerShell)",
            packageRequirement: "LetOctopusDecide",
            runScriptActions: [{
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using PowerShell)",
                runOnServer: true,
                scriptBody: `  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
            }],
            startTrigger: "StartAfterPrevious",
        },
        {
            condition: "Success",
            name: "Hello world (using Bash)",
            packageRequirement: "LetOctopusDecide",
            runScriptActions: [{
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using Bash)",
                runOnServer: true,
                scriptBody: `  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
            }],
            startTrigger: "StartWithPrevious",
        },
    ],
});
// basic deployment process with 2 run a script steps as child steps
const childStepExample = new octopusdeploy.DeploymentProcess("childStepExample", {
    projectId: "Projects-123",
    steps: [{
        condition: "Success",
        name: "Hello world (using PowerShell)",
        packageRequirement: "LetOctopusDecide",
        runScriptActions: [
            {
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using PowerShell)",
                scriptBody: `  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
                sortOrder: 1,
            },
            {
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using Bash)",
                scriptBody: `  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
                sortOrder: 2,
            },
        ],
        startTrigger: "StartAfterPrevious",
        targetRoles: ["hello-world"],
    }],
});
// rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
const childStepRollingDeploymentExample = new octopusdeploy.DeploymentProcess("childStepRollingDeploymentExample", {
    projectId: "Projects-123",
    steps: [{
        condition: "Success",
        name: "Hello world (using PowerShell)",
        packageRequirement: "LetOctopusDecide",
        runScriptActions: [
            {
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using PowerShell)",
                scriptBody: `  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
                sortOrder: 1,
            },
            {
                canBeUsedForProjectVersioning: false,
                condition: "Success",
                isDisabled: false,
                isRequired: true,
                name: "Hello world (using Bash)",
                scriptBody: `  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

`,
                sortOrder: 2,
            },
        ],
        startTrigger: "StartAfterPrevious",
        targetRoles: ["hello-world"],
        windowSize: "2",
    }],
});

import pulumi
import pulumi_octopusdeploy as octopusdeploy

# basic deployment process with 2 run a script steps
example = octopusdeploy.DeploymentProcess("example",
    project_id="Projects-123",
    steps=[
        {
            "condition": "Success",
            "name": "Hello world (using PowerShell)",
            "package_requirement": "LetOctopusDecide",
            "run_script_actions": [{
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using PowerShell)",
                "run_on_server": True,
                "script_body": """  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
            }],
            "start_trigger": "StartAfterPrevious",
        },
        {
            "condition": "Success",
            "name": "Hello world (using Bash)",
            "package_requirement": "LetOctopusDecide",
            "run_script_actions": [{
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using Bash)",
                "run_on_server": True,
                "script_body": """  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
            }],
            "start_trigger": "StartWithPrevious",
        },
    ])
# basic deployment process with 2 run a script steps as child steps
child_step_example = octopusdeploy.DeploymentProcess("childStepExample",
    project_id="Projects-123",
    steps=[{
        "condition": "Success",
        "name": "Hello world (using PowerShell)",
        "package_requirement": "LetOctopusDecide",
        "run_script_actions": [
            {
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using PowerShell)",
                "script_body": """  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
                "sort_order": 1,
            },
            {
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using Bash)",
                "script_body": """  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
                "sort_order": 2,
            },
        ],
        "start_trigger": "StartAfterPrevious",
        "target_roles": ["hello-world"],
    }])
# rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
child_step_rolling_deployment_example = octopusdeploy.DeploymentProcess("childStepRollingDeploymentExample",
    project_id="Projects-123",
    steps=[{
        "condition": "Success",
        "name": "Hello world (using PowerShell)",
        "package_requirement": "LetOctopusDecide",
        "run_script_actions": [
            {
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using PowerShell)",
                "script_body": """  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
                "sort_order": 1,
            },
            {
                "can_be_used_for_project_versioning": False,
                "condition": "Success",
                "is_disabled": False,
                "is_required": True,
                "name": "Hello world (using Bash)",
                "script_body": """  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

""",
                "sort_order": 2,
            },
        ],
        "start_trigger": "StartAfterPrevious",
        "target_roles": ["hello-world"],
        "window_size": "2",
    }])

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/octopusdeploy/octopusdeploy"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// basic deployment process with 2 run a script steps
		_, err := octopusdeploy.NewDeploymentProcess(ctx, "example", &octopusdeploy.DeploymentProcessArgs{
			ProjectId: pulumi.String("Projects-123"),
			Steps: octopusdeploy.DeploymentProcessStepArray{
				&octopusdeploy.DeploymentProcessStepArgs{
					Condition:          pulumi.String("Success"),
					Name:               pulumi.String("Hello world (using PowerShell)"),
					PackageRequirement: pulumi.String("LetOctopusDecide"),
					RunScriptActions: octopusdeploy.DeploymentProcessStepRunScriptActionArray{
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using PowerShell)"),
							RunOnServer:                   pulumi.Bool(true),
							ScriptBody:                    pulumi.String("  Write-Host 'Hello world, using PowerShell'\n  #TODO: Experiment with steps of your own :)\n  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
						},
					},
					StartTrigger: pulumi.String("StartAfterPrevious"),
				},
				&octopusdeploy.DeploymentProcessStepArgs{
					Condition:          pulumi.String("Success"),
					Name:               pulumi.String("Hello world (using Bash)"),
					PackageRequirement: pulumi.String("LetOctopusDecide"),
					RunScriptActions: octopusdeploy.DeploymentProcessStepRunScriptActionArray{
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using Bash)"),
							RunOnServer:                   pulumi.Bool(true),
							ScriptBody:                    pulumi.String("  echo 'Hello world, using Bash'\n  #TODO: Experiment with steps of your own :)\n  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
						},
					},
					StartTrigger: pulumi.String("StartWithPrevious"),
				},
			},
		})
		if err != nil {
			return err
		}
		// basic deployment process with 2 run a script steps as child steps
		_, err = octopusdeploy.NewDeploymentProcess(ctx, "childStepExample", &octopusdeploy.DeploymentProcessArgs{
			ProjectId: pulumi.String("Projects-123"),
			Steps: octopusdeploy.DeploymentProcessStepArray{
				&octopusdeploy.DeploymentProcessStepArgs{
					Condition:          pulumi.String("Success"),
					Name:               pulumi.String("Hello world (using PowerShell)"),
					PackageRequirement: pulumi.String("LetOctopusDecide"),
					RunScriptActions: octopusdeploy.DeploymentProcessStepRunScriptActionArray{
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using PowerShell)"),
							ScriptBody:                    pulumi.String("  Write-Host 'Hello world, using PowerShell'\n  #TODO: Experiment with steps of your own :)\n  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
							SortOrder:                     pulumi.Float64(1),
						},
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using Bash)"),
							ScriptBody:                    pulumi.String("  echo 'Hello world, using Bash'\n  #TODO: Experiment with steps of your own :)\n  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
							SortOrder:                     pulumi.Float64(2),
						},
					},
					StartTrigger: pulumi.String("StartAfterPrevious"),
					TargetRoles: pulumi.StringArray{
						pulumi.String("hello-world"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
		_, err = octopusdeploy.NewDeploymentProcess(ctx, "childStepRollingDeploymentExample", &octopusdeploy.DeploymentProcessArgs{
			ProjectId: pulumi.String("Projects-123"),
			Steps: octopusdeploy.DeploymentProcessStepArray{
				&octopusdeploy.DeploymentProcessStepArgs{
					Condition:          pulumi.String("Success"),
					Name:               pulumi.String("Hello world (using PowerShell)"),
					PackageRequirement: pulumi.String("LetOctopusDecide"),
					RunScriptActions: octopusdeploy.DeploymentProcessStepRunScriptActionArray{
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using PowerShell)"),
							ScriptBody:                    pulumi.String("  Write-Host 'Hello world, using PowerShell'\n  #TODO: Experiment with steps of your own :)\n  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
							SortOrder:                     pulumi.Float64(1),
						},
						&octopusdeploy.DeploymentProcessStepRunScriptActionArgs{
							CanBeUsedForProjectVersioning: pulumi.Bool(false),
							Condition:                     pulumi.String("Success"),
							IsDisabled:                    pulumi.Bool(false),
							IsRequired:                    pulumi.Bool(true),
							Name:                          pulumi.String("Hello world (using Bash)"),
							ScriptBody:                    pulumi.String("  echo 'Hello world, using Bash'\n  #TODO: Experiment with steps of your own :)\n  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'\n\n"),
							SortOrder:                     pulumi.Float64(2),
						},
					},
					StartTrigger: pulumi.String("StartAfterPrevious"),
					TargetRoles: pulumi.StringArray{
						pulumi.String("hello-world"),
					},
					WindowSize: pulumi.String("2"),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // basic deployment process with 2 run a script steps
    var example = new Octopusdeploy.DeploymentProcess("example", new()
    {
        ProjectId = "Projects-123",
        Steps = new[]
        {
            new Octopusdeploy.Inputs.DeploymentProcessStepArgs
            {
                Condition = "Success",
                Name = "Hello world (using PowerShell)",
                PackageRequirement = "LetOctopusDecide",
                RunScriptActions = new[]
                {
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using PowerShell)",
                        RunOnServer = true,
                        ScriptBody = @"  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                    },
                },
                StartTrigger = "StartAfterPrevious",
            },
            new Octopusdeploy.Inputs.DeploymentProcessStepArgs
            {
                Condition = "Success",
                Name = "Hello world (using Bash)",
                PackageRequirement = "LetOctopusDecide",
                RunScriptActions = new[]
                {
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using Bash)",
                        RunOnServer = true,
                        ScriptBody = @"  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                    },
                },
                StartTrigger = "StartWithPrevious",
            },
        },
    });

    // basic deployment process with 2 run a script steps as child steps
    var childStepExample = new Octopusdeploy.DeploymentProcess("childStepExample", new()
    {
        ProjectId = "Projects-123",
        Steps = new[]
        {
            new Octopusdeploy.Inputs.DeploymentProcessStepArgs
            {
                Condition = "Success",
                Name = "Hello world (using PowerShell)",
                PackageRequirement = "LetOctopusDecide",
                RunScriptActions = new[]
                {
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using PowerShell)",
                        ScriptBody = @"  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                        SortOrder = 1,
                    },
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using Bash)",
                        ScriptBody = @"  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                        SortOrder = 2,
                    },
                },
                StartTrigger = "StartAfterPrevious",
                TargetRoles = new[]
                {
                    "hello-world",
                },
            },
        },
    });

    // rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
    var childStepRollingDeploymentExample = new Octopusdeploy.DeploymentProcess("childStepRollingDeploymentExample", new()
    {
        ProjectId = "Projects-123",
        Steps = new[]
        {
            new Octopusdeploy.Inputs.DeploymentProcessStepArgs
            {
                Condition = "Success",
                Name = "Hello world (using PowerShell)",
                PackageRequirement = "LetOctopusDecide",
                RunScriptActions = new[]
                {
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using PowerShell)",
                        ScriptBody = @"  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                        SortOrder = 1,
                    },
                    new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                    {
                        CanBeUsedForProjectVersioning = false,
                        Condition = "Success",
                        IsDisabled = false,
                        IsRequired = true,
                        Name = "Hello world (using Bash)",
                        ScriptBody = @"  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

",
                        SortOrder = 2,
                    },
                },
                StartTrigger = "StartAfterPrevious",
                TargetRoles = new[]
                {
                    "hello-world",
                },
                WindowSize = "2",
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.octopusdeploy.DeploymentProcess;
import com.pulumi.octopusdeploy.DeploymentProcessArgs;
import com.pulumi.octopusdeploy.inputs.DeploymentProcessStepArgs;
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) {
        // basic deployment process with 2 run a script steps
        var example = new DeploymentProcess("example", DeploymentProcessArgs.builder()
            .projectId("Projects-123")
            .steps(            
                DeploymentProcessStepArgs.builder()
                    .condition("Success")
                    .name("Hello world (using PowerShell)")
                    .packageRequirement("LetOctopusDecide")
                    .runScriptActions(DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using PowerShell)")
                        .runOnServer(true)
                        .scriptBody("""
  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .build())
                    .startTrigger("StartAfterPrevious")
                    .build(),
                DeploymentProcessStepArgs.builder()
                    .condition("Success")
                    .name("Hello world (using Bash)")
                    .packageRequirement("LetOctopusDecide")
                    .runScriptActions(DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using Bash)")
                        .runOnServer(true)
                        .scriptBody("""
  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .build())
                    .startTrigger("StartWithPrevious")
                    .build())
            .build());

        // basic deployment process with 2 run a script steps as child steps
        var childStepExample = new DeploymentProcess("childStepExample", DeploymentProcessArgs.builder()
            .projectId("Projects-123")
            .steps(DeploymentProcessStepArgs.builder()
                .condition("Success")
                .name("Hello world (using PowerShell)")
                .packageRequirement("LetOctopusDecide")
                .runScriptActions(                
                    DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using PowerShell)")
                        .scriptBody("""
  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .sortOrder(1)
                        .build(),
                    DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using Bash)")
                        .scriptBody("""
  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .sortOrder(2)
                        .build())
                .startTrigger("StartAfterPrevious")
                .targetRoles("hello-world")
                .build())
            .build());

        // rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
        var childStepRollingDeploymentExample = new DeploymentProcess("childStepRollingDeploymentExample", DeploymentProcessArgs.builder()
            .projectId("Projects-123")
            .steps(DeploymentProcessStepArgs.builder()
                .condition("Success")
                .name("Hello world (using PowerShell)")
                .packageRequirement("LetOctopusDecide")
                .runScriptActions(                
                    DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using PowerShell)")
                        .scriptBody("""
  Write-Host 'Hello world, using PowerShell'
  #TODO: Experiment with steps of your own :)
  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .sortOrder(1)
                        .build(),
                    DeploymentProcessStepRunScriptActionArgs.builder()
                        .canBeUsedForProjectVersioning(false)
                        .condition("Success")
                        .isDisabled(false)
                        .isRequired(true)
                        .name("Hello world (using Bash)")
                        .scriptBody("""
  echo 'Hello world, using Bash'
  #TODO: Experiment with steps of your own :)
  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

                        """)
                        .sortOrder(2)
                        .build())
                .startTrigger("StartAfterPrevious")
                .targetRoles("hello-world")
                .windowSize(2)
                .build())
            .build());

    }
}

resources:
  # basic deployment process with 2 run a script steps
  example:
    type: octopusdeploy:DeploymentProcess
    properties:
      projectId: Projects-123
      steps:
        - condition: Success
          name: Hello world (using PowerShell)
          packageRequirement: LetOctopusDecide
          runScriptActions:
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using PowerShell)
              runOnServer: true
              scriptBody: |2+
                  Write-Host 'Hello world, using PowerShell'
                  #TODO: Experiment with steps of your own :)
                  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

          startTrigger: StartAfterPrevious
        - condition: Success
          name: Hello world (using Bash)
          packageRequirement: LetOctopusDecide
          runScriptActions:
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using Bash)
              runOnServer: true
              scriptBody: |2+
                  echo 'Hello world, using Bash'
                  #TODO: Experiment with steps of your own :)
                  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

          startTrigger: StartWithPrevious
  # basic deployment process with 2 run a script steps as child steps
  childStepExample:
    type: octopusdeploy:DeploymentProcess
    properties:
      projectId: Projects-123
      steps:
        - condition: Success
          name: Hello world (using PowerShell)
          packageRequirement: LetOctopusDecide
          runScriptActions:
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using PowerShell)
              scriptBody: |2+
                  Write-Host 'Hello world, using PowerShell'
                  #TODO: Experiment with steps of your own :)
                  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

              sortOrder: 1
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using Bash)
              scriptBody: |2+
                  echo 'Hello world, using Bash'
                  #TODO: Experiment with steps of your own :)
                  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

              sortOrder: 2
          startTrigger: StartAfterPrevious
          targetRoles:
            - hello-world
  # rolling deployment process with a step with 2 run a script steps as child steps deploying to 2 targets in parallel
  childStepRollingDeploymentExample:
    type: octopusdeploy:DeploymentProcess
    properties:
      projectId: Projects-123
      steps:
        - condition: Success
          name: Hello world (using PowerShell)
          packageRequirement: LetOctopusDecide
          runScriptActions:
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using PowerShell)
              scriptBody: |2+
                  Write-Host 'Hello world, using PowerShell'
                  #TODO: Experiment with steps of your own :)
                  Write-Host '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

              sortOrder: 1
            - canBeUsedForProjectVersioning: false
              condition: Success
              isDisabled: false
              isRequired: true
              name: Hello world (using Bash)
              scriptBody: |2+
                  echo 'Hello world, using Bash'
                  #TODO: Experiment with steps of your own :)
                  echo '[Learn more about the types of steps available in Octopus](https://g.octopushq.com/OnboardingAddStepsLearnMore)'

              sortOrder: 2
          startTrigger: StartAfterPrevious
          targetRoles:
            - hello-world
          windowSize: 2

var deploymentProcessResource = new Octopusdeploy.DeploymentProcess("deploymentProcessResource", new()
{
    ProjectId = "string",
    Branch = "string",
    DeploymentProcessId = "string",
    LastSnapshotId = "string",
    SpaceId = "string",
    Steps = new[]
    {
        new Octopusdeploy.Inputs.DeploymentProcessStepArgs
        {
            Name = "string",
            ManualInterventionActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepManualInterventionActionArgs
                {
                    Instructions = "string",
                    Name = "string",
                    Id = "string",
                    CanBeUsedForProjectVersioning = false,
                    Condition = "string",
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepManualInterventionActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    Environments = new[]
                    {
                        "string",
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepManualInterventionActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepManualInterventionActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    Channels = new[]
                    {
                        "string",
                    },
                    IsDisabled = false,
                    IsRequired = false,
                    BlockDeployments = "string",
                    Notes = "string",
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepManualInterventionActionPackageArgs
                        {
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            FeedId = "string",
                            Id = "string",
                            Name = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    ResponsibleTeams = "string",
                    Slug = "string",
                    SortOrder = 0,
                    TenantTags = new[]
                    {
                        "string",
                    },
                },
            },
            PackageRequirement = "string",
            ConditionExpression = "string",
            DeployKubernetesSecretActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepDeployKubernetesSecretActionArgs
                {
                    Name = "string",
                    SecretValues = 
                    {
                        { "string", "string" },
                    },
                    SecretName = "string",
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Notes = "string",
                    Environments = new[]
                    {
                        "string",
                    },
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepDeployKubernetesSecretActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepDeployKubernetesSecretActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Id = "string",
                    IsDisabled = false,
                    IsRequired = false,
                    KubernetesObjectStatusCheckEnabled = false,
                    Condition = "string",
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployKubernetesSecretActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployKubernetesSecretActionPackageArgs
                        {
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            FeedId = "string",
                            Id = "string",
                            Name = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    RunOnServer = false,
                    Channels = new[]
                    {
                        "string",
                    },
                    CanBeUsedForProjectVersioning = false,
                    Slug = "string",
                    SortOrder = 0,
                    TenantTags = new[]
                    {
                        "string",
                    },
                    WorkerPoolId = "string",
                    WorkerPoolVariable = "string",
                },
            },
            DeployPackageActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionArgs
                {
                    Name = "string",
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    Environments = new[]
                    {
                        "string",
                    },
                    IsRequired = false,
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Id = "string",
                    IsDisabled = false,
                    Condition = "string",
                    Channels = new[]
                    {
                        "string",
                    },
                    Notes = "string",
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionPackageArgs
                        {
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            FeedId = "string",
                            Id = "string",
                            Name = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    CanBeUsedForProjectVersioning = false,
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    Slug = "string",
                    SortOrder = 0,
                    TenantTags = new[]
                    {
                        "string",
                    },
                    WindowsService = new Octopusdeploy.Inputs.DeploymentProcessStepDeployPackageActionWindowsServiceArgs
                    {
                        ExecutablePath = "string",
                        ServiceName = "string",
                        Arguments = "string",
                        CreateOrUpdateService = false,
                        CustomAccountName = "string",
                        CustomAccountPassword = "string",
                        Dependencies = "string",
                        Description = "string",
                        DisplayName = "string",
                        ServiceAccount = "string",
                        StartMode = "string",
                    },
                },
            },
            DeployWindowsServiceActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionArgs
                {
                    ExecutablePath = "string",
                    ServiceName = "string",
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    Name = "string",
                    CustomAccountName = "string",
                    Id = "string",
                    CreateOrUpdateService = false,
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    CustomAccountPassword = "string",
                    Dependencies = "string",
                    Description = "string",
                    DisplayName = "string",
                    Environments = new[]
                    {
                        "string",
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Condition = "string",
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    IsDisabled = false,
                    IsRequired = false,
                    Channels = new[]
                    {
                        "string",
                    },
                    Notes = "string",
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepDeployWindowsServiceActionPackageArgs
                        {
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            FeedId = "string",
                            Id = "string",
                            Name = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    CanBeUsedForProjectVersioning = false,
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    ServiceAccount = "string",
                    Arguments = "string",
                    Slug = "string",
                    SortOrder = 0,
                    StartMode = "string",
                    TenantTags = new[]
                    {
                        "string",
                    },
                },
            },
            Condition = "string",
            Id = "string",
            ApplyTerraformTemplateActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionArgs
                {
                    Name = "string",
                    AdvancedOptions = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionAdvancedOptionsArgs
                    {
                        AllowAdditionalPluginDownloads = false,
                        ApplyParameters = "string",
                        InitParameters = "string",
                        PluginCacheDirectory = "string",
                        Workspace = "string",
                    },
                    InlineTemplate = "string",
                    Template = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionTemplateArgs
                    {
                        AdditionalVariableFiles = "string",
                        Directory = "string",
                        RunAutomaticFileSubstitution = false,
                        TargetFiles = "string",
                    },
                    CanBeUsedForProjectVersioning = false,
                    Channels = new[]
                    {
                        "string",
                    },
                    IsRequired = false,
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    Environments = new[]
                    {
                        "string",
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    GoogleCloudAccount = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionGoogleCloudAccountArgs
                    {
                        ImpersonateServiceAccount = false,
                        Project = "string",
                        Region = "string",
                        ServiceAccountEmails = "string",
                        UseVmServiceAccount = false,
                        Variable = "string",
                        Zone = "string",
                    },
                    Id = "string",
                    AzureAccount = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionAzureAccountArgs
                    {
                        Variable = "string",
                    },
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    Condition = "string",
                    AwsAccount = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionAwsAccountArgs
                    {
                        Region = "string",
                        Role = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionAwsAccountRoleArgs
                        {
                            Arn = "string",
                            ExternalId = "string",
                            RoleSessionName = "string",
                            SessionDuration = 0,
                        },
                        UseInstanceRole = false,
                        Variable = "string",
                    },
                    Notes = "string",
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionPackageArgs
                        {
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            FeedId = "string",
                            Id = "string",
                            Name = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepApplyTerraformTemplateActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    RunOnServer = false,
                    Slug = "string",
                    SortOrder = 0,
                    IsDisabled = false,
                    TemplateParameters = "string",
                    TenantTags = new[]
                    {
                        "string",
                    },
                    WorkerPoolId = "string",
                    WorkerPoolVariable = "string",
                },
            },
            Actions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepActionArgs
                {
                    Name = "string",
                    ActionType = "string",
                    IsRequired = false,
                    CanBeUsedForProjectVersioning = false,
                    Condition = "string",
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    Environments = new[]
                    {
                        "string",
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Id = "string",
                    Notes = "string",
                    Channels = new[]
                    {
                        "string",
                    },
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    IsDisabled = false,
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepActionPackageArgs
                        {
                            Name = "string",
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            ExtractDuringDeployment = false,
                            FeedId = "string",
                            Id = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    RunOnServer = false,
                    Slug = "string",
                    SortOrder = 0,
                    TenantTags = new[]
                    {
                        "string",
                    },
                    WorkerPoolId = "string",
                    WorkerPoolVariable = "string",
                },
            },
            Properties = 
            {
                { "string", "string" },
            },
            RunKubectlScriptActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionArgs
                {
                    Name = "string",
                    Notes = "string",
                    ScriptFileName = "string",
                    Condition = "string",
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    Environments = new[]
                    {
                        "string",
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Id = "string",
                    IsDisabled = false,
                    IsRequired = false,
                    CanBeUsedForProjectVersioning = false,
                    Namespace = "string",
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    Channels = new[]
                    {
                        "string",
                    },
                    Properties = 
                    {
                        { "string", "string" },
                    },
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionPackageArgs
                        {
                            Name = "string",
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            ExtractDuringDeployment = false,
                            FeedId = "string",
                            Id = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    RunOnServer = false,
                    ScriptBody = "string",
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepRunKubectlScriptActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    ScriptParameters = "string",
                    ScriptSource = "string",
                    ScriptSyntax = "string",
                    Slug = "string",
                    SortOrder = 0,
                    TenantTags = new[]
                    {
                        "string",
                    },
                    VariableSubstitutionInFiles = "string",
                    WorkerPoolId = "string",
                    WorkerPoolVariable = "string",
                },
            },
            RunScriptActions = new[]
            {
                new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionArgs
                {
                    Name = "string",
                    Packages = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionPackageArgs
                        {
                            Name = "string",
                            PackageId = "string",
                            AcquisitionLocation = "string",
                            ExtractDuringDeployment = false,
                            FeedId = "string",
                            Id = "string",
                            Properties = 
                            {
                                { "string", "string" },
                            },
                        },
                    },
                    SortOrder = 0,
                    Condition = "string",
                    Containers = new[]
                    {
                        new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionContainerArgs
                        {
                            FeedId = "string",
                            Image = "string",
                        },
                    },
                    PrimaryPackage = new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionPrimaryPackageArgs
                    {
                        PackageId = "string",
                        AcquisitionLocation = "string",
                        FeedId = "string",
                        Id = "string",
                        Name = "string",
                        Properties = 
                        {
                            { "string", "string" },
                        },
                    },
                    ExcludedEnvironments = new[]
                    {
                        "string",
                    },
                    Features = new[]
                    {
                        "string",
                    },
                    GitDependency = new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionGitDependencyArgs
                    {
                        DefaultBranch = "string",
                        GitCredentialType = "string",
                        RepositoryUri = "string",
                        FilePathFilters = new[]
                        {
                            "string",
                        },
                        GitCredentialId = "string",
                    },
                    Id = "string",
                    IsDisabled = false,
                    IsRequired = false,
                    CanBeUsedForProjectVersioning = false,
                    Channels = new[]
                    {
                        "string",
                    },
                    Notes = "string",
                    Environments = new[]
                    {
                        "string",
                    },
                    RunOnServer = false,
                    ScriptBody = "string",
                    ScriptFileName = "string",
                    ScriptParameters = "string",
                    ScriptSource = "string",
                    ScriptSyntax = "string",
                    Slug = "string",
                    ActionTemplate = new Octopusdeploy.Inputs.DeploymentProcessStepRunScriptActionActionTemplateArgs
                    {
                        Id = "string",
                        CommunityActionTemplateId = "string",
                        Version = 0,
                    },
                    TenantTags = new[]
                    {
                        "string",
                    },
                    VariableSubstitutionInFiles = "string",
                    WorkerPoolId = "string",
                    WorkerPoolVariable = "string",
                },
            },
            StartTrigger = "string",
            TargetRoles = new[]
            {
                "string",
            },
            WindowSize = "string",
        },
    },
    Version = 0,
});