harness.platform.InputSet

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

return await Deployment.RunAsync(() => 
{
    var example = new Harness.Platform.InputSet("example", new()
    {
        Identifier = "identifier",
        Tags = new[]
        {
            "foo:bar",
        },
        OrgId = "org_id",
        ProjectId = "project_id",
        PipelineId = "pipeline_id",
        Yaml = @"inputSet:
  identifier: ""identifier""
  name: ""name""
  tags:
    foo: ""bar""
  orgIdentifier: ""org_id""
  projectIdentifier: ""project_id""
  pipeline:
    identifier: ""pipeline_id""
    variables:
    - name: ""key""
      type: ""String""
      value: ""value""
",
    });

    // Remote InputSet
    var test = new Harness.Platform.InputSet("test", new()
    {
        Identifier = "identifier",
        Tags = new[]
        {
            "foo:bar",
        },
        OrgId = harness_platform_organization.Test.Id,
        ProjectId = harness_platform_project.Test.Id,
        PipelineId = harness_platform_pipeline.Test.Id,
        GitDetails = new Harness.Platform.Inputs.InputSetGitDetailsArgs
        {
            BranchName = "main",
            CommitMessage = "Commit",
            FilePath = ".harness/file_path.yaml",
            ConnectorRef = "account.connector_ref",
            StoreType = "REMOTE",
            RepoName = "repo_name",
        },
        Yaml = @$"inputSet:
  identifier: ""identifier""
  name: ""name""
  tags:
    foo: ""bar""
  orgIdentifier: ""{harness_platform_organization.Test.Id}""
  projectIdentifier: ""{harness_platform_project.Test.Id}""
  pipeline:
    identifier: ""{harness_platform_pipeline.Test.Id}""
    variables:
    - name: ""key""
      type: ""String""
      value: ""value""
",
    });

});

package main

import (
	"fmt"

	"github.com/lbrlabs/pulumi-harness/sdk/go/harness/platform"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := platform.NewInputSet(ctx, "example", &platform.InputSetArgs{
			Identifier: pulumi.String("identifier"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
			},
			OrgId:      pulumi.String("org_id"),
			ProjectId:  pulumi.String("project_id"),
			PipelineId: pulumi.String("pipeline_id"),
			Yaml: pulumi.String(`inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "org_id"
  projectIdentifier: "project_id"
  pipeline:
    identifier: "pipeline_id"
    variables:
    - name: "key"
      type: "String"
      value: "value"
`),
		})
		if err != nil {
			return err
		}
		_, err = platform.NewInputSet(ctx, "test", &platform.InputSetArgs{
			Identifier: pulumi.String("identifier"),
			Tags: pulumi.StringArray{
				pulumi.String("foo:bar"),
			},
			OrgId:      pulumi.Any(harness_platform_organization.Test.Id),
			ProjectId:  pulumi.Any(harness_platform_project.Test.Id),
			PipelineId: pulumi.Any(harness_platform_pipeline.Test.Id),
			GitDetails: &platform.InputSetGitDetailsArgs{
				BranchName:    pulumi.String("main"),
				CommitMessage: pulumi.String("Commit"),
				FilePath:      pulumi.String(".harness/file_path.yaml"),
				ConnectorRef:  pulumi.String("account.connector_ref"),
				StoreType:     pulumi.String("REMOTE"),
				RepoName:      pulumi.String("repo_name"),
			},
			Yaml: pulumi.String(fmt.Sprintf(`inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "%v"
  projectIdentifier: "%v"
  pipeline:
    identifier: "%v"
    variables:
    - name: "key"
      type: "String"
      value: "value"
`, harness_platform_organization.Test.Id, harness_platform_project.Test.Id, harness_platform_pipeline.Test.Id)),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.harness.platform.InputSet;
import com.pulumi.harness.platform.InputSetArgs;
import com.pulumi.harness.platform.inputs.InputSetGitDetailsArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var example = new InputSet("example", InputSetArgs.builder()        
            .identifier("identifier")
            .tags("foo:bar")
            .orgId("org_id")
            .projectId("project_id")
            .pipelineId("pipeline_id")
            .yaml("""
inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "org_id"
  projectIdentifier: "project_id"
  pipeline:
    identifier: "pipeline_id"
    variables:
    - name: "key"
      type: "String"
      value: "value"
            """)
            .build());

        var test = new InputSet("test", InputSetArgs.builder()        
            .identifier("identifier")
            .tags("foo:bar")
            .orgId(harness_platform_organization.test().id())
            .projectId(harness_platform_project.test().id())
            .pipelineId(harness_platform_pipeline.test().id())
            .gitDetails(InputSetGitDetailsArgs.builder()
                .branchName("main")
                .commitMessage("Commit")
                .filePath(".harness/file_path.yaml")
                .connectorRef("account.connector_ref")
                .storeType("REMOTE")
                .repoName("repo_name")
                .build())
            .yaml("""
inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "%s"
  projectIdentifier: "%s"
  pipeline:
    identifier: "%s"
    variables:
    - name: "key"
      type: "String"
      value: "value"
", harness_platform_organization.test().id(),harness_platform_project.test().id(),harness_platform_pipeline.test().id()))
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_harness as harness

example = harness.platform.InputSet("example",
    identifier="identifier",
    tags=["foo:bar"],
    org_id="org_id",
    project_id="project_id",
    pipeline_id="pipeline_id",
    yaml="""inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "org_id"
  projectIdentifier: "project_id"
  pipeline:
    identifier: "pipeline_id"
    variables:
    - name: "key"
      type: "String"
      value: "value"
""")
# Remote InputSet
test = harness.platform.InputSet("test",
    identifier="identifier",
    tags=["foo:bar"],
    org_id=harness_platform_organization["test"]["id"],
    project_id=harness_platform_project["test"]["id"],
    pipeline_id=harness_platform_pipeline["test"]["id"],
    git_details=harness.platform.InputSetGitDetailsArgs(
        branch_name="main",
        commit_message="Commit",
        file_path=".harness/file_path.yaml",
        connector_ref="account.connector_ref",
        store_type="REMOTE",
        repo_name="repo_name",
    ),
    yaml=f"""inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "{harness_platform_organization["test"]["id"]}"
  projectIdentifier: "{harness_platform_project["test"]["id"]}"
  pipeline:
    identifier: "{harness_platform_pipeline["test"]["id"]}"
    variables:
    - name: "key"
      type: "String"
      value: "value"
""")

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

const example = new harness.platform.InputSet("example", {
    identifier: "identifier",
    tags: ["foo:bar"],
    orgId: "org_id",
    projectId: "project_id",
    pipelineId: "pipeline_id",
    yaml: `inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "org_id"
  projectIdentifier: "project_id"
  pipeline:
    identifier: "pipeline_id"
    variables:
    - name: "key"
      type: "String"
      value: "value"
`,
});
// Remote InputSet
const test = new harness.platform.InputSet("test", {
    identifier: "identifier",
    tags: ["foo:bar"],
    orgId: harness_platform_organization.test.id,
    projectId: harness_platform_project.test.id,
    pipelineId: harness_platform_pipeline.test.id,
    gitDetails: {
        branchName: "main",
        commitMessage: "Commit",
        filePath: ".harness/file_path.yaml",
        connectorRef: "account.connector_ref",
        storeType: "REMOTE",
        repoName: "repo_name",
    },
    yaml: `inputSet:
  identifier: "identifier"
  name: "name"
  tags:
    foo: "bar"
  orgIdentifier: "${harness_platform_organization.test.id}"
  projectIdentifier: "${harness_platform_project.test.id}"
  pipeline:
    identifier: "${harness_platform_pipeline.test.id}"
    variables:
    - name: "key"
      type: "String"
      value: "value"
`,
});

resources:
  example:
    type: harness:platform:InputSet
    properties:
      identifier: identifier
      tags:
        - foo:bar
      orgId: org_id
      projectId: project_id
      pipelineId: pipeline_id
      yaml: |
        inputSet:
          identifier: "identifier"
          name: "name"
          tags:
            foo: "bar"
          orgIdentifier: "org_id"
          projectIdentifier: "project_id"
          pipeline:
            identifier: "pipeline_id"
            variables:
            - name: "key"
              type: "String"
              value: "value"        
  # Remote InputSet
  test:
    type: harness:platform:InputSet
    properties:
      identifier: identifier
      tags:
        - foo:bar
      orgId: ${harness_platform_organization.test.id}
      projectId: ${harness_platform_project.test.id}
      pipelineId: ${harness_platform_pipeline.test.id}
      gitDetails:
        branchName: main
        commitMessage: Commit
        filePath: .harness/file_path.yaml
        connectorRef: account.connector_ref
        storeType: REMOTE
        repoName: repo_name
      yaml: |
        inputSet:
          identifier: "identifier"
          name: "name"
          tags:
            foo: "bar"
          orgIdentifier: "${harness_platform_organization.test.id}"
          projectIdentifier: "${harness_platform_project.test.id}"
          pipeline:
            identifier: "${harness_platform_pipeline.test.id}"
            variables:
            - name: "key"
              type: "String"
              value: "value"