launchdarkly.FeatureFlagEnvironment

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

return await Deployment.RunAsync(() => 
{
    var numberEnv = new Launchdarkly.FeatureFlagEnvironment("numberEnv", new()
    {
        FlagId = launchdarkly_feature_flag.Number.Id,
        EnvKey = launchdarkly_environment.Staging.Key,
        On = true,
        Prerequisites = new[]
        {
            new Launchdarkly.Inputs.FeatureFlagEnvironmentPrerequisiteArgs
            {
                FlagKey = launchdarkly_feature_flag.Basic.Key,
                Variation = 0,
            },
        },
        Targets = new[]
        {
            new Launchdarkly.Inputs.FeatureFlagEnvironmentTargetArgs
            {
                Values = new[]
                {
                    "user0",
                },
                Variation = 0,
            },
            new Launchdarkly.Inputs.FeatureFlagEnvironmentTargetArgs
            {
                Values = new[]
                {
                    "user1",
                    "user2",
                },
                Variation = 1,
            },
        },
        Rules = new[]
        {
            new Launchdarkly.Inputs.FeatureFlagEnvironmentRuleArgs
            {
                Clauses = new[]
                {
                    new Launchdarkly.Inputs.FeatureFlagEnvironmentRuleClauseArgs
                    {
                        Attribute = "country",
                        Op = "startsWith",
                        Values = new[]
                        {
                            "aus",
                            "de",
                            "united",
                        },
                        Negate = false,
                    },
                    new Launchdarkly.Inputs.FeatureFlagEnvironmentRuleClauseArgs
                    {
                        Attribute = "segmentMatch",
                        Op = "segmentMatch",
                        Values = new[]
                        {
                            launchdarkly_segment.Example.Key,
                        },
                        Negate = false,
                    },
                },
                Variation = 0,
            },
        },
        Fallthrough = new Launchdarkly.Inputs.FeatureFlagEnvironmentFallthroughArgs
        {
            RolloutWeights = new[]
            {
                60000,
                40000,
                0,
            },
        },
        OffVariation = 2,
    });

});

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.NewFeatureFlagEnvironment(ctx, "numberEnv", &launchdarkly.FeatureFlagEnvironmentArgs{
			FlagId: pulumi.Any(launchdarkly_feature_flag.Number.Id),
			EnvKey: pulumi.Any(launchdarkly_environment.Staging.Key),
			On:     pulumi.Bool(true),
			Prerequisites: launchdarkly.FeatureFlagEnvironmentPrerequisiteArray{
				&launchdarkly.FeatureFlagEnvironmentPrerequisiteArgs{
					FlagKey:   pulumi.Any(launchdarkly_feature_flag.Basic.Key),
					Variation: pulumi.Int(0),
				},
			},
			Targets: launchdarkly.FeatureFlagEnvironmentTargetArray{
				&launchdarkly.FeatureFlagEnvironmentTargetArgs{
					Values: pulumi.StringArray{
						pulumi.String("user0"),
					},
					Variation: pulumi.Int(0),
				},
				&launchdarkly.FeatureFlagEnvironmentTargetArgs{
					Values: pulumi.StringArray{
						pulumi.String("user1"),
						pulumi.String("user2"),
					},
					Variation: pulumi.Int(1),
				},
			},
			Rules: launchdarkly.FeatureFlagEnvironmentRuleArray{
				&launchdarkly.FeatureFlagEnvironmentRuleArgs{
					Clauses: launchdarkly.FeatureFlagEnvironmentRuleClauseArray{
						&launchdarkly.FeatureFlagEnvironmentRuleClauseArgs{
							Attribute: pulumi.String("country"),
							Op:        pulumi.String("startsWith"),
							Values: pulumi.StringArray{
								pulumi.String("aus"),
								pulumi.String("de"),
								pulumi.String("united"),
							},
							Negate: pulumi.Bool(false),
						},
						&launchdarkly.FeatureFlagEnvironmentRuleClauseArgs{
							Attribute: pulumi.String("segmentMatch"),
							Op:        pulumi.String("segmentMatch"),
							Values: pulumi.StringArray{
								launchdarkly_segment.Example.Key,
							},
							Negate: pulumi.Bool(false),
						},
					},
					Variation: pulumi.Int(0),
				},
			},
			Fallthrough: &launchdarkly.FeatureFlagEnvironmentFallthroughArgs{
				RolloutWeights: pulumi.IntArray{
					pulumi.Int(60000),
					pulumi.Int(40000),
					pulumi.Int(0),
				},
			},
			OffVariation: pulumi.Int(2),
		})
		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.FeatureFlagEnvironment;
import com.pulumi.launchdarkly.FeatureFlagEnvironmentArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagEnvironmentPrerequisiteArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagEnvironmentTargetArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagEnvironmentRuleArgs;
import com.pulumi.launchdarkly.inputs.FeatureFlagEnvironmentFallthroughArgs;
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 numberEnv = new FeatureFlagEnvironment("numberEnv", FeatureFlagEnvironmentArgs.builder()        
            .flagId(launchdarkly_feature_flag.number().id())
            .envKey(launchdarkly_environment.staging().key())
            .on(true)
            .prerequisites(FeatureFlagEnvironmentPrerequisiteArgs.builder()
                .flagKey(launchdarkly_feature_flag.basic().key())
                .variation(0)
                .build())
            .targets(            
                FeatureFlagEnvironmentTargetArgs.builder()
                    .values("user0")
                    .variation(0)
                    .build(),
                FeatureFlagEnvironmentTargetArgs.builder()
                    .values(                    
                        "user1",
                        "user2")
                    .variation(1)
                    .build())
            .rules(FeatureFlagEnvironmentRuleArgs.builder()
                .clauses(                
                    FeatureFlagEnvironmentRuleClauseArgs.builder()
                        .attribute("country")
                        .op("startsWith")
                        .values(                        
                            "aus",
                            "de",
                            "united")
                        .negate(false)
                        .build(),
                    FeatureFlagEnvironmentRuleClauseArgs.builder()
                        .attribute("segmentMatch")
                        .op("segmentMatch")
                        .values(launchdarkly_segment.example().key())
                        .negate(false)
                        .build())
                .variation(0)
                .build())
            .fallthrough(FeatureFlagEnvironmentFallthroughArgs.builder()
                .rolloutWeights(                
                    60000,
                    40000,
                    0)
                .build())
            .offVariation(2)
            .build());

    }
}

import pulumi
import lbrlabs_pulumi_launchdarkly as launchdarkly

number_env = launchdarkly.FeatureFlagEnvironment("numberEnv",
    flag_id=launchdarkly_feature_flag["number"]["id"],
    env_key=launchdarkly_environment["staging"]["key"],
    on=True,
    prerequisites=[launchdarkly.FeatureFlagEnvironmentPrerequisiteArgs(
        flag_key=launchdarkly_feature_flag["basic"]["key"],
        variation=0,
    )],
    targets=[
        launchdarkly.FeatureFlagEnvironmentTargetArgs(
            values=["user0"],
            variation=0,
        ),
        launchdarkly.FeatureFlagEnvironmentTargetArgs(
            values=[
                "user1",
                "user2",
            ],
            variation=1,
        ),
    ],
    rules=[launchdarkly.FeatureFlagEnvironmentRuleArgs(
        clauses=[
            launchdarkly.FeatureFlagEnvironmentRuleClauseArgs(
                attribute="country",
                op="startsWith",
                values=[
                    "aus",
                    "de",
                    "united",
                ],
                negate=False,
            ),
            launchdarkly.FeatureFlagEnvironmentRuleClauseArgs(
                attribute="segmentMatch",
                op="segmentMatch",
                values=[launchdarkly_segment["example"]["key"]],
                negate=False,
            ),
        ],
        variation=0,
    )],
    fallthrough=launchdarkly.FeatureFlagEnvironmentFallthroughArgs(
        rollout_weights=[
            60000,
            40000,
            0,
        ],
    ),
    off_variation=2)

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

const numberEnv = new launchdarkly.FeatureFlagEnvironment("numberEnv", {
    flagId: launchdarkly_feature_flag.number.id,
    envKey: launchdarkly_environment.staging.key,
    on: true,
    prerequisites: [{
        flagKey: launchdarkly_feature_flag.basic.key,
        variation: 0,
    }],
    targets: [
        {
            values: ["user0"],
            variation: 0,
        },
        {
            values: [
                "user1",
                "user2",
            ],
            variation: 1,
        },
    ],
    rules: [{
        clauses: [
            {
                attribute: "country",
                op: "startsWith",
                values: [
                    "aus",
                    "de",
                    "united",
                ],
                negate: false,
            },
            {
                attribute: "segmentMatch",
                op: "segmentMatch",
                values: [launchdarkly_segment.example.key],
                negate: false,
            },
        ],
        variation: 0,
    }],
    fallthrough: {
        rolloutWeights: [
            60000,
            40000,
            0,
        ],
    },
    offVariation: 2,
});

resources:
  numberEnv:
    type: launchdarkly:FeatureFlagEnvironment
    properties:
      flagId: ${launchdarkly_feature_flag.number.id}
      envKey: ${launchdarkly_environment.staging.key}
      on: true
      prerequisites:
        - flagKey: ${launchdarkly_feature_flag.basic.key}
          variation: 0
      targets:
        - values:
            - user0
          variation: 0
        - values:
            - user1
            - user2
          variation: 1
      rules:
        - clauses:
            - attribute: country
              op: startsWith
              values:
                - aus
                - de
                - united
              negate: false
            - attribute: segmentMatch
              op: segmentMatch
              values:
                - ${launchdarkly_segment.example.key}
              negate: false
          variation: 0
      fallthrough:
        rolloutWeights:
          - 60000
          - 40000
          - 0
      offVariation: 2