launchdarkly.FeatureFlag

using System.Collections.Generic;
using Pulumi;
using Launchdarkly = Lbrlabs.PulumiPackage.Launchdarkly;

return await Deployment.RunAsync(() => 
{
    var buildingMaterials = new Launchdarkly.FeatureFlag("buildingMaterials", new()
    {
        ProjectKey = launchdarkly_project.Example.Key,
        Key = "building-materials",
        Description = "this is a multivariate flag with string variations.",
        VariationType = "string",
        Variations = new[]
        {
            new Launchdarkly.Inputs.FeatureFlagVariationArgs
            {
                Value = "straw",
                Name = "Straw",
                Description = "Watch out for wind.",
            },
            new Launchdarkly.Inputs.FeatureFlagVariationArgs
            {
                Value = "sticks",
                Name = "Sticks",
                Description = "Sturdier than straw",
            },
            new Launchdarkly.Inputs.FeatureFlagVariationArgs
            {
                Value = "bricks",
                Name = "Bricks",
                Description = "The strongest variation",
            },
        },
        Defaults = new Launchdarkly.Inputs.FeatureFlagDefaultsArgs
        {
            OnVariation = 2,
            OffVariation = 0,
        },
        Tags = new[]
        {
            "example",
            "terraform",
            "multivariate",
            "building-materials",
        },
    });

});

package main

import (
	"github.com/lbrlabs/pulumi-launchdarkly/sdk/go/launchdarkly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := launchdarkly.NewFeatureFlag(ctx, "buildingMaterials", &launchdarkly.FeatureFlagArgs{
			ProjectKey:    pulumi.Any(launchdarkly_project.Example.Key),
			Key:           pulumi.String("building-materials"),
			Description:   pulumi.String("this is a multivariate flag with string variations."),
			VariationType: pulumi.String("string"),
			Variations: launchdarkly.FeatureFlagVariationArray{
				&launchdarkly.FeatureFlagVariationArgs{
					Value:       pulumi.String("straw"),
					Name:        pulumi.String("Straw"),
					Description: pulumi.String("Watch out for wind."),
				},
				&launchdarkly.FeatureFlagVariationArgs{
					Value:       pulumi.String("sticks"),
					Name:        pulumi.String("Sticks"),
					Description: pulumi.String("Sturdier than straw"),
				},
				&launchdarkly.FeatureFlagVariationArgs{
					Value:       pulumi.String("bricks"),
					Name:        pulumi.String("Bricks"),
					Description: pulumi.String("The strongest variation"),
				},
			},
			Defaults: &launchdarkly.FeatureFlagDefaultsArgs{
				OnVariation:  pulumi.Int(2),
				OffVariation: pulumi.Int(0),
			},
			Tags: pulumi.StringArray{
				pulumi.String("example"),
				pulumi.String("terraform"),
				pulumi.String("multivariate"),
				pulumi.String("building-materials"),
			},
		})
		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.launchdarkly.FeatureFlag;
import com.pulumi.launchdarkly.FeatureFlagArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagVariationArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagDefaultsArgs;
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 buildingMaterials = new FeatureFlag("buildingMaterials", FeatureFlagArgs.builder()        
            .projectKey(launchdarkly_project.example().key())
            .key("building-materials")
            .description("this is a multivariate flag with string variations.")
            .variationType("string")
            .variations(            
                FeatureFlagVariationArgs.builder()
                    .value("straw")
                    .name("Straw")
                    .description("Watch out for wind.")
                    .build(),
                FeatureFlagVariationArgs.builder()
                    .value("sticks")
                    .name("Sticks")
                    .description("Sturdier than straw")
                    .build(),
                FeatureFlagVariationArgs.builder()
                    .value("bricks")
                    .name("Bricks")
                    .description("The strongest variation")
                    .build())
            .defaults(FeatureFlagDefaultsArgs.builder()
                .onVariation(2)
                .offVariation(0)
                .build())
            .tags(            
                "example",
                "terraform",
                "multivariate",
                "building-materials")
            .build());

    }
}

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

const buildingMaterials = new launchdarkly.FeatureFlag("buildingMaterials", {
    projectKey: launchdarkly_project.example.key,
    key: "building-materials",
    description: "this is a multivariate flag with string variations.",
    variationType: "string",
    variations: [
        {
            value: "straw",
            name: "Straw",
            description: "Watch out for wind.",
        },
        {
            value: "sticks",
            name: "Sticks",
            description: "Sturdier than straw",
        },
        {
            value: "bricks",
            name: "Bricks",
            description: "The strongest variation",
        },
    ],
    defaults: {
        onVariation: 2,
        offVariation: 0,
    },
    tags: [
        "example",
        "terraform",
        "multivariate",
        "building-materials",
    ],
});

import pulumi
import lbrlabs_pulumi_launchdarkly as launchdarkly

building_materials = launchdarkly.FeatureFlag("buildingMaterials",
    project_key=launchdarkly_project["example"]["key"],
    key="building-materials",
    description="this is a multivariate flag with string variations.",
    variation_type="string",
    variations=[
        launchdarkly.FeatureFlagVariationArgs(
            value="straw",
            name="Straw",
            description="Watch out for wind.",
        ),
        launchdarkly.FeatureFlagVariationArgs(
            value="sticks",
            name="Sticks",
            description="Sturdier than straw",
        ),
        launchdarkly.FeatureFlagVariationArgs(
            value="bricks",
            name="Bricks",
            description="The strongest variation",
        ),
    ],
    defaults=launchdarkly.FeatureFlagDefaultsArgs(
        on_variation=2,
        off_variation=0,
    ),
    tags=[
        "example",
        "terraform",
        "multivariate",
        "building-materials",
    ])

resources:
  buildingMaterials:
    type: launchdarkly:FeatureFlag
    properties:
      projectKey: ${launchdarkly_project.example.key}
      key: building-materials
      description: this is a multivariate flag with string variations.
      variationType: string
      variations:
        - value: straw
          name: Straw
          description: Watch out for wind.
        - value: sticks
          name: Sticks
          description: Sturdier than straw
        - value: bricks
          name: Bricks
          description: The strongest variation
      defaults:
        onVariation: 2
        offVariation: 0
      tags:
        - example
        - terraform
        - multivariate
        - building-materials

using System.Collections.Generic;
using System.Text.Json;
using Pulumi;
using Launchdarkly = Lbrlabs.PulumiPackage.Launchdarkly;

return await Deployment.RunAsync(() => 
{
    var jsonExample = new Launchdarkly.FeatureFlag("jsonExample", new()
    {
        ProjectKey = "example-project",
        Key = "json-example",
        VariationType = "json",
        Variations = new[]
        {
            new Launchdarkly.Inputs.FeatureFlagVariationArgs
            {
                Name = "Single foo",
                Value = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["foo"] = "bar",
                }),
            },
            new Launchdarkly.Inputs.FeatureFlagVariationArgs
            {
                Name = "Multiple foos",
                Value = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["foos"] = new[]
                    {
                        "bar1",
                        "bar2",
                    },
                }),
            },
        },
        Defaults = new Launchdarkly.Inputs.FeatureFlagDefaultsArgs
        {
            OnVariation = 1,
            OffVariation = 0,
        },
    });

});

package main

import (
	"encoding/json"

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"foo": "bar",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"foos": []string{
				"bar1",
				"bar2",
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		_, err = launchdarkly.NewFeatureFlag(ctx, "jsonExample", &launchdarkly.FeatureFlagArgs{
			ProjectKey:    pulumi.String("example-project"),
			Key:           pulumi.String("json-example"),
			VariationType: pulumi.String("json"),
			Variations: launchdarkly.FeatureFlagVariationArray{
				&launchdarkly.FeatureFlagVariationArgs{
					Name:  pulumi.String("Single foo"),
					Value: pulumi.String(json0),
				},
				&launchdarkly.FeatureFlagVariationArgs{
					Name:  pulumi.String("Multiple foos"),
					Value: pulumi.String(json1),
				},
			},
			Defaults: &launchdarkly.FeatureFlagDefaultsArgs{
				OnVariation:  pulumi.Int(1),
				OffVariation: pulumi.Int(0),
			},
		})
		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.launchdarkly.FeatureFlag;
import com.pulumi.launchdarkly.FeatureFlagArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagVariationArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagDefaultsArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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 jsonExample = new FeatureFlag("jsonExample", FeatureFlagArgs.builder()        
            .projectKey("example-project")
            .key("json-example")
            .variationType("json")
            .variations(            
                FeatureFlagVariationArgs.builder()
                    .name("Single foo")
                    .value(serializeJson(
                        jsonObject(
                            jsonProperty("foo", "bar")
                        )))
                    .build(),
                FeatureFlagVariationArgs.builder()
                    .name("Multiple foos")
                    .value(serializeJson(
                        jsonObject(
                            jsonProperty("foos", jsonArray(
                                "bar1", 
                                "bar2"
                            ))
                        )))
                    .build())
            .defaults(FeatureFlagDefaultsArgs.builder()
                .onVariation(1)
                .offVariation(0)
                .build())
            .build());

    }
}

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

const jsonExample = new launchdarkly.FeatureFlag("jsonExample", {
    projectKey: "example-project",
    key: "json-example",
    variationType: "json",
    variations: [
        {
            name: "Single foo",
            value: JSON.stringify({
                foo: "bar",
            }),
        },
        {
            name: "Multiple foos",
            value: JSON.stringify({
                foos: [
                    "bar1",
                    "bar2",
                ],
            }),
        },
    ],
    defaults: {
        onVariation: 1,
        offVariation: 0,
    },
});

import pulumi
import json
import lbrlabs_pulumi_launchdarkly as launchdarkly

json_example = launchdarkly.FeatureFlag("jsonExample",
    project_key="example-project",
    key="json-example",
    variation_type="json",
    variations=[
        launchdarkly.FeatureFlagVariationArgs(
            name="Single foo",
            value=json.dumps({
                "foo": "bar",
            }),
        ),
        launchdarkly.FeatureFlagVariationArgs(
            name="Multiple foos",
            value=json.dumps({
                "foos": [
                    "bar1",
                    "bar2",
                ],
            }),
        ),
    ],
    defaults=launchdarkly.FeatureFlagDefaultsArgs(
        on_variation=1,
        off_variation=0,
    ))

resources:
  jsonExample:
    type: launchdarkly:FeatureFlag
    properties:
      projectKey: example-project
      key: json-example
      variationType: json
      variations:
        - name: Single foo
          value:
            fn::toJSON:
              foo: bar
        - name: Multiple foos
          value:
            fn::toJSON:
              foos:
                - bar1
                - bar2
      defaults:
        onVariation: 1
        offVariation: 0