harness.chaos.SecurityGovernanceConditionV3

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

// Example of a Kubernetes Security Governance Condition (V3)
const k8sCondition = new harness.chaos.SecurityGovernanceConditionV3("k8s_condition", {
    orgId: orgId,
    projectId: projectId,
    name: "k8s-security-condition",
    description: "Security governance condition for Kubernetes workloads",
    infraType: "KubernetesV2",
    faultSpec: {
        operator: "NOT_EQUAL_TO",
        faults: [
            {
                faultType: "FAULT",
                name: "pod-delete",
            },
            {
                faultType: "FAULT",
                name: "pod-dns",
            },
        ],
    },
    k8sSpec: {
        infraSpec: {
            operator: "EQUAL_TO",
            infraIds: [k8sInfraId],
        },
        applicationSpec: {
            operator: "EQUAL_TO",
            workloads: [{
                namespace: "default",
                kind: "deployment",
                label: "app=nginx",
                services: ["nginx-service"],
                applicationMapId: "nginx-app",
            }],
        },
        chaosServiceAccountSpec: {
            operator: "EQUAL_TO",
            serviceAccounts: [
                "default",
                "chaos-service-account",
            ],
        },
    },
    tags: [
        "env:prod",
        "team:security",
        "platform:k8s",
    ],
});
// Example of a Linux Security Governance Condition (V3)
const linuxCondition = new harness.chaos.SecurityGovernanceConditionV3("linux_condition", {
    orgId: orgId,
    projectId: projectId,
    name: "linux-security-condition",
    description: "Security governance condition for Linux hosts",
    infraType: "Linux",
    faultSpec: {
        operator: "NOT_EQUAL_TO",
        faults: [
            {
                faultType: "FAULT",
                name: "process-kill",
            },
            {
                faultType: "FAULT",
                name: "memory-hog",
            },
        ],
    },
    machineSpec: {
        infraSpec: {
            operator: "EQUAL_TO",
            infraIds: [linuxInfraId],
        },
    },
    tags: [
        "env:prod",
        "team:security",
        "platform:linux",
    ],
});
export const k8sConditionV3Id = k8sCondition.id;
export const linuxConditionV3Id = linuxCondition.id;

import pulumi
import pulumi_harness as harness

# Example of a Kubernetes Security Governance Condition (V3)
k8s_condition = harness.chaos.SecurityGovernanceConditionV3("k8s_condition",
    org_id=org_id,
    project_id=project_id,
    name="k8s-security-condition",
    description="Security governance condition for Kubernetes workloads",
    infra_type="KubernetesV2",
    fault_spec={
        "operator": "NOT_EQUAL_TO",
        "faults": [
            {
                "fault_type": "FAULT",
                "name": "pod-delete",
            },
            {
                "fault_type": "FAULT",
                "name": "pod-dns",
            },
        ],
    },
    k8s_spec={
        "infra_spec": {
            "operator": "EQUAL_TO",
            "infra_ids": [k8s_infra_id],
        },
        "application_spec": {
            "operator": "EQUAL_TO",
            "workloads": [{
                "namespace": "default",
                "kind": "deployment",
                "label": "app=nginx",
                "services": ["nginx-service"],
                "application_map_id": "nginx-app",
            }],
        },
        "chaos_service_account_spec": {
            "operator": "EQUAL_TO",
            "service_accounts": [
                "default",
                "chaos-service-account",
            ],
        },
    },
    tags=[
        "env:prod",
        "team:security",
        "platform:k8s",
    ])
# Example of a Linux Security Governance Condition (V3)
linux_condition = harness.chaos.SecurityGovernanceConditionV3("linux_condition",
    org_id=org_id,
    project_id=project_id,
    name="linux-security-condition",
    description="Security governance condition for Linux hosts",
    infra_type="Linux",
    fault_spec={
        "operator": "NOT_EQUAL_TO",
        "faults": [
            {
                "fault_type": "FAULT",
                "name": "process-kill",
            },
            {
                "fault_type": "FAULT",
                "name": "memory-hog",
            },
        ],
    },
    machine_spec={
        "infra_spec": {
            "operator": "EQUAL_TO",
            "infra_ids": [linux_infra_id],
        },
    },
    tags=[
        "env:prod",
        "team:security",
        "platform:linux",
    ])
pulumi.export("k8sConditionV3Id", k8s_condition.id)
pulumi.export("linuxConditionV3Id", linux_condition.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Example of a Kubernetes Security Governance Condition (V3)
		k8sCondition, err := chaos.NewSecurityGovernanceConditionV3(ctx, "k8s_condition", &chaos.SecurityGovernanceConditionV3Args{
			OrgId:       pulumi.Any(orgId),
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.String("k8s-security-condition"),
			Description: pulumi.String("Security governance condition for Kubernetes workloads"),
			InfraType:   pulumi.String("KubernetesV2"),
			FaultSpec: &chaos.SecurityGovernanceConditionV3FaultSpecArgs{
				Operator: pulumi.String("NOT_EQUAL_TO"),
				Faults: chaos.SecurityGovernanceConditionV3FaultSpecFaultArray{
					&chaos.SecurityGovernanceConditionV3FaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("pod-delete"),
					},
					&chaos.SecurityGovernanceConditionV3FaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("pod-dns"),
					},
				},
			},
			K8sSpec: &chaos.SecurityGovernanceConditionV3K8sSpecArgs{
				InfraSpec: &chaos.SecurityGovernanceConditionV3K8sSpecInfraSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					InfraIds: pulumi.StringArray{
						k8sInfraId,
					},
				},
				ApplicationSpec: &chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					Workloads: chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArray{
						&chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs{
							Namespace: pulumi.String("default"),
							Kind:      pulumi.String("deployment"),
							Label:     pulumi.String("app=nginx"),
							Services: pulumi.StringArray{
								pulumi.String("nginx-service"),
							},
							ApplicationMapId: pulumi.String("nginx-app"),
						},
					},
				},
				ChaosServiceAccountSpec: &chaos.SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					ServiceAccounts: pulumi.StringArray{
						pulumi.String("default"),
						pulumi.String("chaos-service-account"),
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("team:security"),
				pulumi.String("platform:k8s"),
			},
		})
		if err != nil {
			return err
		}
		// Example of a Linux Security Governance Condition (V3)
		linuxCondition, err := chaos.NewSecurityGovernanceConditionV3(ctx, "linux_condition", &chaos.SecurityGovernanceConditionV3Args{
			OrgId:       pulumi.Any(orgId),
			ProjectId:   pulumi.Any(projectId),
			Name:        pulumi.String("linux-security-condition"),
			Description: pulumi.String("Security governance condition for Linux hosts"),
			InfraType:   pulumi.String("Linux"),
			FaultSpec: &chaos.SecurityGovernanceConditionV3FaultSpecArgs{
				Operator: pulumi.String("NOT_EQUAL_TO"),
				Faults: chaos.SecurityGovernanceConditionV3FaultSpecFaultArray{
					&chaos.SecurityGovernanceConditionV3FaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("process-kill"),
					},
					&chaos.SecurityGovernanceConditionV3FaultSpecFaultArgs{
						FaultType: pulumi.String("FAULT"),
						Name:      pulumi.String("memory-hog"),
					},
				},
			},
			MachineSpec: &chaos.SecurityGovernanceConditionV3MachineSpecArgs{
				InfraSpec: &chaos.SecurityGovernanceConditionV3MachineSpecInfraSpecArgs{
					Operator: pulumi.String("EQUAL_TO"),
					InfraIds: pulumi.StringArray{
						linuxInfraId,
					},
				},
			},
			Tags: pulumi.StringArray{
				pulumi.String("env:prod"),
				pulumi.String("team:security"),
				pulumi.String("platform:linux"),
			},
		})
		if err != nil {
			return err
		}
		ctx.Export("k8sConditionV3Id", k8sCondition.ID())
		ctx.Export("linuxConditionV3Id", linuxCondition.ID())
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Example of a Kubernetes Security Governance Condition (V3)
    var k8sCondition = new Harness.Chaos.SecurityGovernanceConditionV3("k8s_condition", new()
    {
        OrgId = orgId,
        ProjectId = projectId,
        Name = "k8s-security-condition",
        Description = "Security governance condition for Kubernetes workloads",
        InfraType = "KubernetesV2",
        FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecArgs
        {
            Operator = "NOT_EQUAL_TO",
            Faults = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "pod-delete",
                },
                new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "pod-dns",
                },
            },
        },
        K8sSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecArgs
        {
            InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecInfraSpecArgs
            {
                Operator = "EQUAL_TO",
                InfraIds = new[]
                {
                    k8sInfraId,
                },
            },
            ApplicationSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs
            {
                Operator = "EQUAL_TO",
                Workloads = new[]
                {
                    new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs
                    {
                        Namespace = "default",
                        Kind = "deployment",
                        Label = "app=nginx",
                        Services = new[]
                        {
                            "nginx-service",
                        },
                        ApplicationMapId = "nginx-app",
                    },
                },
            },
            ChaosServiceAccountSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs
            {
                Operator = "EQUAL_TO",
                ServiceAccounts = new[]
                {
                    "default",
                    "chaos-service-account",
                },
            },
        },
        Tags = new[]
        {
            "env:prod",
            "team:security",
            "platform:k8s",
        },
    });

    // Example of a Linux Security Governance Condition (V3)
    var linuxCondition = new Harness.Chaos.SecurityGovernanceConditionV3("linux_condition", new()
    {
        OrgId = orgId,
        ProjectId = projectId,
        Name = "linux-security-condition",
        Description = "Security governance condition for Linux hosts",
        InfraType = "Linux",
        FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecArgs
        {
            Operator = "NOT_EQUAL_TO",
            Faults = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "process-kill",
                },
                new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs
                {
                    FaultType = "FAULT",
                    Name = "memory-hog",
                },
            },
        },
        MachineSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3MachineSpecArgs
        {
            InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3MachineSpecInfraSpecArgs
            {
                Operator = "EQUAL_TO",
                InfraIds = new[]
                {
                    linuxInfraId,
                },
            },
        },
        Tags = new[]
        {
            "env:prod",
            "team:security",
            "platform:linux",
        },
    });

    return new Dictionary<string, object?>
    {
        ["k8sConditionV3Id"] = k8sCondition.Id,
        ["linuxConditionV3Id"] = linuxCondition.Id,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.chaos.SecurityGovernanceConditionV3;
import com.pulumi.harness.chaos.SecurityGovernanceConditionV3Args;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3FaultSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3K8sSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3K8sSpecInfraSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3MachineSpecArgs;
import com.pulumi.harness.chaos.inputs.SecurityGovernanceConditionV3MachineSpecInfraSpecArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Example of a Kubernetes Security Governance Condition (V3)
        var k8sCondition = new SecurityGovernanceConditionV3("k8sCondition", SecurityGovernanceConditionV3Args.builder()
            .orgId(orgId)
            .projectId(projectId)
            .name("k8s-security-condition")
            .description("Security governance condition for Kubernetes workloads")
            .infraType("KubernetesV2")
            .faultSpec(SecurityGovernanceConditionV3FaultSpecArgs.builder()
                .operator("NOT_EQUAL_TO")
                .faults(                
                    SecurityGovernanceConditionV3FaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("pod-delete")
                        .build(),
                    SecurityGovernanceConditionV3FaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("pod-dns")
                        .build())
                .build())
            .k8sSpec(SecurityGovernanceConditionV3K8sSpecArgs.builder()
                .infraSpec(SecurityGovernanceConditionV3K8sSpecInfraSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .infraIds(k8sInfraId)
                    .build())
                .applicationSpec(SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .workloads(SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs.builder()
                        .namespace("default")
                        .kind("deployment")
                        .label("app=nginx")
                        .services("nginx-service")
                        .applicationMapId("nginx-app")
                        .build())
                    .build())
                .chaosServiceAccountSpec(SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .serviceAccounts(                    
                        "default",
                        "chaos-service-account")
                    .build())
                .build())
            .tags(            
                "env:prod",
                "team:security",
                "platform:k8s")
            .build());

        // Example of a Linux Security Governance Condition (V3)
        var linuxCondition = new SecurityGovernanceConditionV3("linuxCondition", SecurityGovernanceConditionV3Args.builder()
            .orgId(orgId)
            .projectId(projectId)
            .name("linux-security-condition")
            .description("Security governance condition for Linux hosts")
            .infraType("Linux")
            .faultSpec(SecurityGovernanceConditionV3FaultSpecArgs.builder()
                .operator("NOT_EQUAL_TO")
                .faults(                
                    SecurityGovernanceConditionV3FaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("process-kill")
                        .build(),
                    SecurityGovernanceConditionV3FaultSpecFaultArgs.builder()
                        .faultType("FAULT")
                        .name("memory-hog")
                        .build())
                .build())
            .machineSpec(SecurityGovernanceConditionV3MachineSpecArgs.builder()
                .infraSpec(SecurityGovernanceConditionV3MachineSpecInfraSpecArgs.builder()
                    .operator("EQUAL_TO")
                    .infraIds(linuxInfraId)
                    .build())
                .build())
            .tags(            
                "env:prod",
                "team:security",
                "platform:linux")
            .build());

        ctx.export("k8sConditionV3Id", k8sCondition.id());
        ctx.export("linuxConditionV3Id", linuxCondition.id());
    }
}

resources:
  # Example of a Kubernetes Security Governance Condition (V3)
  k8sCondition:
    type: harness:chaos:SecurityGovernanceConditionV3
    name: k8s_condition
    properties:
      orgId: ${orgId}
      projectId: ${projectId}
      name: k8s-security-condition
      description: Security governance condition for Kubernetes workloads
      infraType: KubernetesV2
      faultSpec:
        operator: NOT_EQUAL_TO
        faults:
          - faultType: FAULT
            name: pod-delete
          - faultType: FAULT
            name: pod-dns
      k8sSpec:
        infraSpec:
          operator: EQUAL_TO
          infraIds:
            - ${k8sInfraId}
        applicationSpec:
          operator: EQUAL_TO
          workloads:
            - namespace: default
              kind: deployment
              label: app=nginx
              services:
                - nginx-service
              applicationMapId: nginx-app
        chaosServiceAccountSpec:
          operator: EQUAL_TO
          serviceAccounts:
            - default
            - chaos-service-account
      tags:
        - env:prod
        - team:security
        - platform:k8s
  # Example of a Linux Security Governance Condition (V3)
  linuxCondition:
    type: harness:chaos:SecurityGovernanceConditionV3
    name: linux_condition
    properties:
      orgId: ${orgId}
      projectId: ${projectId}
      name: linux-security-condition
      description: Security governance condition for Linux hosts
      infraType: Linux
      faultSpec:
        operator: NOT_EQUAL_TO
        faults:
          - faultType: FAULT
            name: process-kill
          - faultType: FAULT
            name: memory-hog
      machineSpec:
        infraSpec:
          operator: EQUAL_TO
          infraIds:
            - ${linuxInfraId}
      tags:
        - env:prod
        - team:security
        - platform:linux
outputs:
  # Output the created conditions
  k8sConditionV3Id: ${k8sCondition.id}
  linuxConditionV3Id: ${linuxCondition.id}

pulumi {
  required_providers {
    harness = {
      source = "pulumi/harness"
    }
  }
}

# Example of a Kubernetes Security Governance Condition (V3)
resource "harness_chaos_securitygovernanceconditionv3" "k8s_condition" {
  org_id      = orgId
  project_id  = projectId
  name        = "k8s-security-condition"
  description = "Security governance condition for Kubernetes workloads"
  infra_type  = "KubernetesV2"
  fault_spec = {
    operator = "NOT_EQUAL_TO"
    faults = [{
      "faultType" = "FAULT"
      "name"      = "pod-delete"
      }, {
      "faultType" = "FAULT"
      "name"      = "pod-dns"
    }]
  }
  k8s_spec = {
    infra_spec = {
      operator  = "EQUAL_TO"
      infra_ids = [k8sInfraId]
    }
    application_spec = {
      operator = "EQUAL_TO"
      workloads = [{
        "namespace"        = "default"
        "kind"             = "deployment"
        "label"            = "app=nginx"
        "services"         = ["nginx-service"]
        "applicationMapId" = "nginx-app"
      }]
    }
    chaos_service_account_spec = {
      operator         = "EQUAL_TO"
      service_accounts = ["default", "chaos-service-account"]
    }
  }
  tags = ["env:prod", "team:security", "platform:k8s"]
}
# Example of a Linux Security Governance Condition (V3)
resource "harness_chaos_securitygovernanceconditionv3" "linux_condition" {
  org_id      = orgId
  project_id  = projectId
  name        = "linux-security-condition"
  description = "Security governance condition for Linux hosts"
  infra_type  = "Linux"
  fault_spec = {
    operator = "NOT_EQUAL_TO"
    faults = [{
      "faultType" = "FAULT"
      "name"      = "process-kill"
      }, {
      "faultType" = "FAULT"
      "name"      = "memory-hog"
    }]
  }
  machine_spec = {
    infra_spec = {
      operator  = "EQUAL_TO"
      infra_ids = [linuxInfraId]
    }
  }
  tags = ["env:prod", "team:security", "platform:linux"]
}
# Output the created conditions
output "k8sConditionV3Id" {
  value = harness_chaos_securitygovernanceconditionv3.k8s_condition.id
}
output "linuxConditionV3Id" {
  value = harness_chaos_securitygovernanceconditionv3.linux_condition.id
}

var securityGovernanceConditionV3Resource = new Harness.Chaos.SecurityGovernanceConditionV3("securityGovernanceConditionV3Resource", new()
{
    FaultSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecArgs
    {
        Faults = new[]
        {
            new Harness.Chaos.Inputs.SecurityGovernanceConditionV3FaultSpecFaultArgs
            {
                FaultType = "string",
                Name = "string",
            },
        },
        Operator = "string",
    },
    InfraType = "string",
    OrgId = "string",
    ProjectId = "string",
    Description = "string",
    K8sSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecArgs
    {
        ApplicationSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs
        {
            Operator = "string",
            Workloads = new[]
            {
                new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs
                {
                    Namespace = "string",
                    ApplicationMapId = "string",
                    Kind = "string",
                    Label = "string",
                    NamespaceLabels = 
                    {
                        { "string", "string" },
                    },
                    Services = new[]
                    {
                        "string",
                    },
                },
            },
        },
        ChaosServiceAccountSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs
        {
            Operator = "string",
            ServiceAccounts = new[]
            {
                "string",
            },
        },
        InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3K8sSpecInfraSpecArgs
        {
            InfraIds = new[]
            {
                "string",
            },
            Operator = "string",
        },
    },
    MachineSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3MachineSpecArgs
    {
        InfraSpec = new Harness.Chaos.Inputs.SecurityGovernanceConditionV3MachineSpecInfraSpecArgs
        {
            InfraIds = new[]
            {
                "string",
            },
            Operator = "string",
        },
    },
    Name = "string",
    Tags = new[]
    {
        "string",
    },
});

example, err := chaos.NewSecurityGovernanceConditionV3(ctx, "securityGovernanceConditionV3Resource", &chaos.SecurityGovernanceConditionV3Args{
	FaultSpec: &chaos.SecurityGovernanceConditionV3FaultSpecArgs{
		Faults: chaos.SecurityGovernanceConditionV3FaultSpecFaultArray{
			&chaos.SecurityGovernanceConditionV3FaultSpecFaultArgs{
				FaultType: pulumi.String("string"),
				Name:      pulumi.String("string"),
			},
		},
		Operator: pulumi.String("string"),
	},
	InfraType:   pulumi.String("string"),
	OrgId:       pulumi.String("string"),
	ProjectId:   pulumi.String("string"),
	Description: pulumi.String("string"),
	K8sSpec: &chaos.SecurityGovernanceConditionV3K8sSpecArgs{
		ApplicationSpec: &chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs{
			Operator: pulumi.String("string"),
			Workloads: chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArray{
				&chaos.SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs{
					Namespace:        pulumi.String("string"),
					ApplicationMapId: pulumi.String("string"),
					Kind:             pulumi.String("string"),
					Label:            pulumi.String("string"),
					NamespaceLabels: pulumi.StringMap{
						"string": pulumi.String("string"),
					},
					Services: pulumi.StringArray{
						pulumi.String("string"),
					},
				},
			},
		},
		ChaosServiceAccountSpec: &chaos.SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs{
			Operator: pulumi.String("string"),
			ServiceAccounts: pulumi.StringArray{
				pulumi.String("string"),
			},
		},
		InfraSpec: &chaos.SecurityGovernanceConditionV3K8sSpecInfraSpecArgs{
			InfraIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Operator: pulumi.String("string"),
		},
	},
	MachineSpec: &chaos.SecurityGovernanceConditionV3MachineSpecArgs{
		InfraSpec: &chaos.SecurityGovernanceConditionV3MachineSpecInfraSpecArgs{
			InfraIds: pulumi.StringArray{
				pulumi.String("string"),
			},
			Operator: pulumi.String("string"),
		},
	},
	Name: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

resource "harness_chaos_securitygovernanceconditionv3" "securityGovernanceConditionV3Resource" {
  fault_spec = {
    faults = [{
      "faultType" = "string"
      "name"      = "string"
    }]
    operator = "string"
  }
  infra_type  = "string"
  org_id      = "string"
  project_id  = "string"
  description = "string"
  k8s_spec = {
    application_spec = {
      operator = "string"
      workloads = [{
        "namespace"        = "string"
        "applicationMapId" = "string"
        "kind"             = "string"
        "label"            = "string"
        "namespaceLabels" = {
          "string" = "string"
        }
        "services" = ["string"]
      }]
    }
    chaos_service_account_spec = {
      operator         = "string"
      service_accounts = ["string"]
    }
    infra_spec = {
      infra_ids = ["string"]
      operator  = "string"
    }
  }
  machine_spec = {
    infra_spec = {
      infra_ids = ["string"]
      operator  = "string"
    }
  }
  name = "string"
  tags = ["string"]
}

var securityGovernanceConditionV3Resource = new SecurityGovernanceConditionV3("securityGovernanceConditionV3Resource", SecurityGovernanceConditionV3Args.builder()
    .faultSpec(SecurityGovernanceConditionV3FaultSpecArgs.builder()
        .faults(SecurityGovernanceConditionV3FaultSpecFaultArgs.builder()
            .faultType("string")
            .name("string")
            .build())
        .operator("string")
        .build())
    .infraType("string")
    .orgId("string")
    .projectId("string")
    .description("string")
    .k8sSpec(SecurityGovernanceConditionV3K8sSpecArgs.builder()
        .applicationSpec(SecurityGovernanceConditionV3K8sSpecApplicationSpecArgs.builder()
            .operator("string")
            .workloads(SecurityGovernanceConditionV3K8sSpecApplicationSpecWorkloadArgs.builder()
                .namespace("string")
                .applicationMapId("string")
                .kind("string")
                .label("string")
                .namespaceLabels(Map.of("string", "string"))
                .services("string")
                .build())
            .build())
        .chaosServiceAccountSpec(SecurityGovernanceConditionV3K8sSpecChaosServiceAccountSpecArgs.builder()
            .operator("string")
            .serviceAccounts("string")
            .build())
        .infraSpec(SecurityGovernanceConditionV3K8sSpecInfraSpecArgs.builder()
            .infraIds("string")
            .operator("string")
            .build())
        .build())
    .machineSpec(SecurityGovernanceConditionV3MachineSpecArgs.builder()
        .infraSpec(SecurityGovernanceConditionV3MachineSpecInfraSpecArgs.builder()
            .infraIds("string")
            .operator("string")
            .build())
        .build())
    .name("string")
    .tags("string")
    .build());

security_governance_condition_v3_resource = harness.chaos.SecurityGovernanceConditionV3("securityGovernanceConditionV3Resource",
    fault_spec={
        "faults": [{
            "fault_type": "string",
            "name": "string",
        }],
        "operator": "string",
    },
    infra_type="string",
    org_id="string",
    project_id="string",
    description="string",
    k8s_spec={
        "application_spec": {
            "operator": "string",
            "workloads": [{
                "namespace": "string",
                "application_map_id": "string",
                "kind": "string",
                "label": "string",
                "namespace_labels": {
                    "string": "string",
                },
                "services": ["string"],
            }],
        },
        "chaos_service_account_spec": {
            "operator": "string",
            "service_accounts": ["string"],
        },
        "infra_spec": {
            "infra_ids": ["string"],
            "operator": "string",
        },
    },
    machine_spec={
        "infra_spec": {
            "infra_ids": ["string"],
            "operator": "string",
        },
    },
    name="string",
    tags=["string"])

const securityGovernanceConditionV3Resource = new harness.chaos.SecurityGovernanceConditionV3("securityGovernanceConditionV3Resource", {
    faultSpec: {
        faults: [{
            faultType: "string",
            name: "string",
        }],
        operator: "string",
    },
    infraType: "string",
    orgId: "string",
    projectId: "string",
    description: "string",
    k8sSpec: {
        applicationSpec: {
            operator: "string",
            workloads: [{
                namespace: "string",
                applicationMapId: "string",
                kind: "string",
                label: "string",
                namespaceLabels: {
                    string: "string",
                },
                services: ["string"],
            }],
        },
        chaosServiceAccountSpec: {
            operator: "string",
            serviceAccounts: ["string"],
        },
        infraSpec: {
            infraIds: ["string"],
            operator: "string",
        },
    },
    machineSpec: {
        infraSpec: {
            infraIds: ["string"],
            operator: "string",
        },
    },
    name: "string",
    tags: ["string"],
});

type: harness:chaos:SecurityGovernanceConditionV3
properties:
    description: string
    faultSpec:
        faults:
            - faultType: string
              name: string
        operator: string
    infraType: string
    k8sSpec:
        applicationSpec:
            operator: string
            workloads:
                - applicationMapId: string
                  kind: string
                  label: string
                  namespace: string
                  namespaceLabels:
                    string: string
                  services:
                    - string
        chaosServiceAccountSpec:
            operator: string
            serviceAccounts:
                - string
        infraSpec:
            infraIds:
                - string
            operator: string
    machineSpec:
        infraSpec:
            infraIds:
                - string
            operator: string
    name: string
    orgId: string
    projectId: string
    tags:
        - string