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

// ============================================================================
// Harness Chaos Experiment Resource Examples
// ============================================================================
//
// Chaos Experiments are INSTANCES created FROM Experiment Templates.
// These examples are based on TESTED configurations from the e2e-test suite.
//
// Key Points:
// - Experiments are created by "launching" an experiment template
// - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
// - Hub scope can be different from experiment scope (cross-scope support)
// - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
// ============================================================================
// ----------------------------------------------------------------------------
// Example 1: Basic Experiment with REFERENCE Import
// ----------------------------------------------------------------------------
// Most common pattern: project-level experiment from project-level template
const basic = new harness.chaos.Experiment("basic", {
    orgId: "my_org",
    projectId: "my_project",
    hubOrgId: "my_org",
    hubProjectId: "my_project",
    hubIdentity: "my-chaos-hub",
    templateIdentity: "my-template",
    infraRef: "my-env/my-infra",
    name: "My Chaos Experiment",
    identity: "my-chaos-experiment",
    description: "Basic chaos experiment with REFERENCE import",
    importType: "REFERENCE",
    tags: [
        "chaos",
        "kubernetes",
        "resilience",
    ],
}, {
    dependsOn: [
        myTemplate,
        myInfra,
    ],
});
// ----------------------------------------------------------------------------
// Example 2: Experiment with LOCAL Import
// ----------------------------------------------------------------------------
// LOCAL import creates a full copy - independent of template changes
const localCopy = new harness.chaos.Experiment("local_copy", {
    orgId: "my_org",
    projectId: "my_project",
    hubOrgId: "my_org",
    hubProjectId: "my_project",
    hubIdentity: "my-chaos-hub",
    templateIdentity: "my-template",
    infraRef: "my-env/my-infra",
    name: "My Independent Experiment",
    identity: "my-independent-experiment",
    description: "Experiment with LOCAL import (independent copy)",
    importType: "LOCAL",
    tags: [
        "chaos",
        "local",
        "independent",
    ],
}, {
    dependsOn: [
        myTemplate,
        myInfra,
    ],
});
// ----------------------------------------------------------------------------
// Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
// ----------------------------------------------------------------------------
// Create project experiment from org-level template (cross-scope)
const crossScope = new harness.chaos.Experiment("cross_scope", {
    orgId: "my_org",
    projectId: "my_project",
    hubOrgId: "my_org",
    hubIdentity: "my-chaos-hub",
    templateIdentity: "my-template",
    infraRef: "my-env/my-infra",
    name: "Cross-Scope Experiment",
    identity: "cross-scope-experiment",
    description: "Project experiment from org-level template",
    importType: "REFERENCE",
    tags: [
        "chaos",
        "cross-scope",
        "org-template",
    ],
}, {
    dependsOn: [
        orgTemplate,
        myInfra,
    ],
});

import pulumi
import pulumi_harness as harness

# ============================================================================
# Harness Chaos Experiment Resource Examples
# ============================================================================
#
# Chaos Experiments are INSTANCES created FROM Experiment Templates.
# These examples are based on TESTED configurations from the e2e-test suite.
#
# Key Points:
# - Experiments are created by "launching" an experiment template
# - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
# - Hub scope can be different from experiment scope (cross-scope support)
# - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
# ============================================================================
# ----------------------------------------------------------------------------
# Example 1: Basic Experiment with REFERENCE Import
# ----------------------------------------------------------------------------
# Most common pattern: project-level experiment from project-level template
basic = harness.chaos.Experiment("basic",
    org_id="my_org",
    project_id="my_project",
    hub_org_id="my_org",
    hub_project_id="my_project",
    hub_identity="my-chaos-hub",
    template_identity="my-template",
    infra_ref="my-env/my-infra",
    name="My Chaos Experiment",
    identity="my-chaos-experiment",
    description="Basic chaos experiment with REFERENCE import",
    import_type="REFERENCE",
    tags=[
        "chaos",
        "kubernetes",
        "resilience",
    ],
    opts = pulumi.ResourceOptions(depends_on=[
            my_template,
            my_infra,
        ]))
# ----------------------------------------------------------------------------
# Example 2: Experiment with LOCAL Import
# ----------------------------------------------------------------------------
# LOCAL import creates a full copy - independent of template changes
local_copy = harness.chaos.Experiment("local_copy",
    org_id="my_org",
    project_id="my_project",
    hub_org_id="my_org",
    hub_project_id="my_project",
    hub_identity="my-chaos-hub",
    template_identity="my-template",
    infra_ref="my-env/my-infra",
    name="My Independent Experiment",
    identity="my-independent-experiment",
    description="Experiment with LOCAL import (independent copy)",
    import_type="LOCAL",
    tags=[
        "chaos",
        "local",
        "independent",
    ],
    opts = pulumi.ResourceOptions(depends_on=[
            my_template,
            my_infra,
        ]))
# ----------------------------------------------------------------------------
# Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
# ----------------------------------------------------------------------------
# Create project experiment from org-level template (cross-scope)
cross_scope = harness.chaos.Experiment("cross_scope",
    org_id="my_org",
    project_id="my_project",
    hub_org_id="my_org",
    hub_identity="my-chaos-hub",
    template_identity="my-template",
    infra_ref="my-env/my-infra",
    name="Cross-Scope Experiment",
    identity="cross-scope-experiment",
    description="Project experiment from org-level template",
    import_type="REFERENCE",
    tags=[
        "chaos",
        "cross-scope",
        "org-template",
    ],
    opts = pulumi.ResourceOptions(depends_on=[
            org_template,
            my_infra,
        ]))

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 {
		// ============================================================================
		// Harness Chaos Experiment Resource Examples
		// ============================================================================
		//
		// Chaos Experiments are INSTANCES created FROM Experiment Templates.
		// These examples are based on TESTED configurations from the e2e-test suite.
		//
		// Key Points:
		// - Experiments are created by "launching" an experiment template
		// - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
		// - Hub scope can be different from experiment scope (cross-scope support)
		// - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
		// ============================================================================
		// ----------------------------------------------------------------------------
		// Example 1: Basic Experiment with REFERENCE Import
		// ----------------------------------------------------------------------------
		// Most common pattern: project-level experiment from project-level template
		_, err := chaos.NewExperiment(ctx, "basic", &chaos.ExperimentArgs{
			OrgId:            pulumi.String("my_org"),
			ProjectId:        pulumi.String("my_project"),
			HubOrgId:         pulumi.String("my_org"),
			HubProjectId:     pulumi.String("my_project"),
			HubIdentity:      pulumi.String("my-chaos-hub"),
			TemplateIdentity: pulumi.String("my-template"),
			InfraRef:         pulumi.String("my-env/my-infra"),
			Name:             pulumi.String("My Chaos Experiment"),
			Identity:         pulumi.String("my-chaos-experiment"),
			Description:      pulumi.String("Basic chaos experiment with REFERENCE import"),
			ImportType:       pulumi.String("REFERENCE"),
			Tags: pulumi.StringArray{
				pulumi.String("chaos"),
				pulumi.String("kubernetes"),
				pulumi.String("resilience"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			myTemplate,
			myInfra,
		}))
		if err != nil {
			return err
		}
		// ----------------------------------------------------------------------------
		// Example 2: Experiment with LOCAL Import
		// ----------------------------------------------------------------------------
		// LOCAL import creates a full copy - independent of template changes
		_, err = chaos.NewExperiment(ctx, "local_copy", &chaos.ExperimentArgs{
			OrgId:            pulumi.String("my_org"),
			ProjectId:        pulumi.String("my_project"),
			HubOrgId:         pulumi.String("my_org"),
			HubProjectId:     pulumi.String("my_project"),
			HubIdentity:      pulumi.String("my-chaos-hub"),
			TemplateIdentity: pulumi.String("my-template"),
			InfraRef:         pulumi.String("my-env/my-infra"),
			Name:             pulumi.String("My Independent Experiment"),
			Identity:         pulumi.String("my-independent-experiment"),
			Description:      pulumi.String("Experiment with LOCAL import (independent copy)"),
			ImportType:       pulumi.String("LOCAL"),
			Tags: pulumi.StringArray{
				pulumi.String("chaos"),
				pulumi.String("local"),
				pulumi.String("independent"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			myTemplate,
			myInfra,
		}))
		if err != nil {
			return err
		}
		// ----------------------------------------------------------------------------
		// Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
		// ----------------------------------------------------------------------------
		// Create project experiment from org-level template (cross-scope)
		_, err = chaos.NewExperiment(ctx, "cross_scope", &chaos.ExperimentArgs{
			OrgId:            pulumi.String("my_org"),
			ProjectId:        pulumi.String("my_project"),
			HubOrgId:         pulumi.String("my_org"),
			HubIdentity:      pulumi.String("my-chaos-hub"),
			TemplateIdentity: pulumi.String("my-template"),
			InfraRef:         pulumi.String("my-env/my-infra"),
			Name:             pulumi.String("Cross-Scope Experiment"),
			Identity:         pulumi.String("cross-scope-experiment"),
			Description:      pulumi.String("Project experiment from org-level template"),
			ImportType:       pulumi.String("REFERENCE"),
			Tags: pulumi.StringArray{
				pulumi.String("chaos"),
				pulumi.String("cross-scope"),
				pulumi.String("org-template"),
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			orgTemplate,
			myInfra,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // ============================================================================
    // Harness Chaos Experiment Resource Examples
    // ============================================================================
    //
    // Chaos Experiments are INSTANCES created FROM Experiment Templates.
    // These examples are based on TESTED configurations from the e2e-test suite.
    //
    // Key Points:
    // - Experiments are created by "launching" an experiment template
    // - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
    // - Hub scope can be different from experiment scope (cross-scope support)
    // - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
    // ============================================================================
    // ----------------------------------------------------------------------------
    // Example 1: Basic Experiment with REFERENCE Import
    // ----------------------------------------------------------------------------
    // Most common pattern: project-level experiment from project-level template
    var basic = new Harness.Chaos.Experiment("basic", new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        HubOrgId = "my_org",
        HubProjectId = "my_project",
        HubIdentity = "my-chaos-hub",
        TemplateIdentity = "my-template",
        InfraRef = "my-env/my-infra",
        Name = "My Chaos Experiment",
        Identity = "my-chaos-experiment",
        Description = "Basic chaos experiment with REFERENCE import",
        ImportType = "REFERENCE",
        Tags = new[]
        {
            "chaos",
            "kubernetes",
            "resilience",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myTemplate,
            myInfra,
        },
    });

    // ----------------------------------------------------------------------------
    // Example 2: Experiment with LOCAL Import
    // ----------------------------------------------------------------------------
    // LOCAL import creates a full copy - independent of template changes
    var localCopy = new Harness.Chaos.Experiment("local_copy", new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        HubOrgId = "my_org",
        HubProjectId = "my_project",
        HubIdentity = "my-chaos-hub",
        TemplateIdentity = "my-template",
        InfraRef = "my-env/my-infra",
        Name = "My Independent Experiment",
        Identity = "my-independent-experiment",
        Description = "Experiment with LOCAL import (independent copy)",
        ImportType = "LOCAL",
        Tags = new[]
        {
            "chaos",
            "local",
            "independent",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myTemplate,
            myInfra,
        },
    });

    // ----------------------------------------------------------------------------
    // Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
    // ----------------------------------------------------------------------------
    // Create project experiment from org-level template (cross-scope)
    var crossScope = new Harness.Chaos.Experiment("cross_scope", new()
    {
        OrgId = "my_org",
        ProjectId = "my_project",
        HubOrgId = "my_org",
        HubIdentity = "my-chaos-hub",
        TemplateIdentity = "my-template",
        InfraRef = "my-env/my-infra",
        Name = "Cross-Scope Experiment",
        Identity = "cross-scope-experiment",
        Description = "Project experiment from org-level template",
        ImportType = "REFERENCE",
        Tags = new[]
        {
            "chaos",
            "cross-scope",
            "org-template",
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            orgTemplate,
            myInfra,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.chaos.Experiment;
import com.pulumi.harness.chaos.ExperimentArgs;
import com.pulumi.resources.CustomResourceOptions;
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) {
        // ============================================================================
        // Harness Chaos Experiment Resource Examples
        // ============================================================================
        //
        // Chaos Experiments are INSTANCES created FROM Experiment Templates.
        // These examples are based on TESTED configurations from the e2e-test suite.
        //
        // Key Points:
        // - Experiments are created by "launching" an experiment template
        // - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
        // - Hub scope can be different from experiment scope (cross-scope support)
        // - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
        // ============================================================================
        // ----------------------------------------------------------------------------
        // Example 1: Basic Experiment with REFERENCE Import
        // ----------------------------------------------------------------------------
        // Most common pattern: project-level experiment from project-level template
        var basic = new Experiment("basic", ExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .hubOrgId("my_org")
            .hubProjectId("my_project")
            .hubIdentity("my-chaos-hub")
            .templateIdentity("my-template")
            .infraRef("my-env/my-infra")
            .name("My Chaos Experiment")
            .identity("my-chaos-experiment")
            .description("Basic chaos experiment with REFERENCE import")
            .importType("REFERENCE")
            .tags(            
                "chaos",
                "kubernetes",
                "resilience")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    myTemplate,
                    myInfra)
                .build());

        // ----------------------------------------------------------------------------
        // Example 2: Experiment with LOCAL Import
        // ----------------------------------------------------------------------------
        // LOCAL import creates a full copy - independent of template changes
        var localCopy = new Experiment("localCopy", ExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .hubOrgId("my_org")
            .hubProjectId("my_project")
            .hubIdentity("my-chaos-hub")
            .templateIdentity("my-template")
            .infraRef("my-env/my-infra")
            .name("My Independent Experiment")
            .identity("my-independent-experiment")
            .description("Experiment with LOCAL import (independent copy)")
            .importType("LOCAL")
            .tags(            
                "chaos",
                "local",
                "independent")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    myTemplate,
                    myInfra)
                .build());

        // ----------------------------------------------------------------------------
        // Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
        // ----------------------------------------------------------------------------
        // Create project experiment from org-level template (cross-scope)
        var crossScope = new Experiment("crossScope", ExperimentArgs.builder()
            .orgId("my_org")
            .projectId("my_project")
            .hubOrgId("my_org")
            .hubIdentity("my-chaos-hub")
            .templateIdentity("my-template")
            .infraRef("my-env/my-infra")
            .name("Cross-Scope Experiment")
            .identity("cross-scope-experiment")
            .description("Project experiment from org-level template")
            .importType("REFERENCE")
            .tags(            
                "chaos",
                "cross-scope",
                "org-template")
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    orgTemplate,
                    myInfra)
                .build());

    }
}

resources:
  # ============================================================================
  # Harness Chaos Experiment Resource Examples
  # ============================================================================
  #
  # Chaos Experiments are INSTANCES created FROM Experiment Templates.
  # These examples are based on TESTED configurations from the e2e-test suite.
  #
  # Key Points:
  # - Experiments are created by "launching" an experiment template
  # - Infrastructure binding (infra_ref) is MANDATORY (format: env_id/infra_id)
  # - Hub scope can be different from experiment scope (cross-scope support)
  # - import_type: "REFERENCE" (default) or "LOCAL" (full copy)
  # ============================================================================

  # ----------------------------------------------------------------------------
  # Example 1: Basic Experiment with REFERENCE Import
  # ----------------------------------------------------------------------------
  # Most common pattern: project-level experiment from project-level template
  basic:
    type: harness:chaos:Experiment
    properties:
      orgId: my_org
      projectId: my_project
      hubOrgId: my_org
      hubProjectId: my_project
      hubIdentity: my-chaos-hub
      templateIdentity: my-template
      infraRef: my-env/my-infra
      name: My Chaos Experiment
      identity: my-chaos-experiment
      description: Basic chaos experiment with REFERENCE import
      importType: REFERENCE
      tags:
        - chaos
        - kubernetes
        - resilience
    options:
      dependsOn:
        - ${myTemplate}
        - ${myInfra}
  # ----------------------------------------------------------------------------
  # Example 2: Experiment with LOCAL Import
  # ----------------------------------------------------------------------------
  # LOCAL import creates a full copy - independent of template changes
  localCopy:
    type: harness:chaos:Experiment
    name: local_copy
    properties:
      orgId: my_org
      projectId: my_project
      hubOrgId: my_org
      hubProjectId: my_project
      hubIdentity: my-chaos-hub
      templateIdentity: my-template
      infraRef: my-env/my-infra
      name: My Independent Experiment
      identity: my-independent-experiment
      description: Experiment with LOCAL import (independent copy)
      importType: LOCAL
      tags:
        - chaos
        - local
        - independent
    options:
      dependsOn:
        - ${myTemplate}
        - ${myInfra}
  # ----------------------------------------------------------------------------
  # Example 3: Cross-Scope Experiment (Org Hub → Project Experiment)
  # ----------------------------------------------------------------------------
  # Create project experiment from org-level template (cross-scope)
  crossScope:
    type: harness:chaos:Experiment
    name: cross_scope
    properties:
      orgId: my_org
      projectId: my_project
      hubOrgId: my_org
      hubIdentity: my-chaos-hub
      templateIdentity: my-template
      infraRef: my-env/my-infra
      name: Cross-Scope Experiment
      identity: cross-scope-experiment
      description: Project experiment from org-level template
      importType: REFERENCE
      tags:
        - chaos
        - cross-scope
        - org-template
    options:
      dependsOn:
        - ${orgTemplate}
        - ${myInfra}

var experimentResource = new Harness.Chaos.Experiment("experimentResource", new()
{
    ProjectId = "string",
    HubIdentity = "string",
    InfraRef = "string",
    OrgId = "string",
    TemplateIdentity = "string",
    HubOrgId = "string",
    HubProjectId = "string",
    Identity = "string",
    ImportType = "string",
    Name = "string",
    Description = "string",
    Revision = "string",
    Tags = new[]
    {
        "string",
    },
});

example, err := chaos.NewExperiment(ctx, "experimentResource", &chaos.ExperimentArgs{
	ProjectId:        pulumi.String("string"),
	HubIdentity:      pulumi.String("string"),
	InfraRef:         pulumi.String("string"),
	OrgId:            pulumi.String("string"),
	TemplateIdentity: pulumi.String("string"),
	HubOrgId:         pulumi.String("string"),
	HubProjectId:     pulumi.String("string"),
	Identity:         pulumi.String("string"),
	ImportType:       pulumi.String("string"),
	Name:             pulumi.String("string"),
	Description:      pulumi.String("string"),
	Revision:         pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

var experimentResource = new Experiment("experimentResource", ExperimentArgs.builder()
    .projectId("string")
    .hubIdentity("string")
    .infraRef("string")
    .orgId("string")
    .templateIdentity("string")
    .hubOrgId("string")
    .hubProjectId("string")
    .identity("string")
    .importType("string")
    .name("string")
    .description("string")
    .revision("string")
    .tags("string")
    .build());

experiment_resource = harness.chaos.Experiment("experimentResource",
    project_id="string",
    hub_identity="string",
    infra_ref="string",
    org_id="string",
    template_identity="string",
    hub_org_id="string",
    hub_project_id="string",
    identity="string",
    import_type="string",
    name="string",
    description="string",
    revision="string",
    tags=["string"])

const experimentResource = new harness.chaos.Experiment("experimentResource", {
    projectId: "string",
    hubIdentity: "string",
    infraRef: "string",
    orgId: "string",
    templateIdentity: "string",
    hubOrgId: "string",
    hubProjectId: "string",
    identity: "string",
    importType: "string",
    name: "string",
    description: "string",
    revision: "string",
    tags: ["string"],
});

type: harness:chaos:Experiment
properties:
    description: string
    hubIdentity: string
    hubOrgId: string
    hubProjectId: string
    identity: string
    importType: string
    infraRef: string
    name: string
    orgId: string
    projectId: string
    revision: string
    tags:
        - string
    templateIdentity: string