launchdarkly.Segment

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

return await Deployment.RunAsync(() => 
{
    var example = new Launchdarkly.Segment("example", new()
    {
        Key = "example-segment-key",
        ProjectKey = launchdarkly_project.Example.Key,
        EnvKey = launchdarkly_environment.Example.Key,
        Description = "This segment is managed by Terraform",
        Tags = new[]
        {
            "segment-tag-1",
            "segment-tag-2",
        },
        Includeds = new[]
        {
            "user1",
            "user2",
        },
        Excludeds = new[]
        {
            "user3",
            "user4",
        },
        Rules = new[]
        {
            new Launchdarkly.Inputs.SegmentRuleArgs
            {
                Clauses = new[]
                {
                    new Launchdarkly.Inputs.SegmentRuleClauseArgs
                    {
                        Attribute = "country",
                        Op = "startsWith",
                        Values = new[]
                        {
                            "en",
                            "de",
                            "un",
                        },
                        Negate = false,
                    },
                },
            },
        },
    });

});

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.NewSegment(ctx, "example", &launchdarkly.SegmentArgs{
			Key:         pulumi.String("example-segment-key"),
			ProjectKey:  pulumi.Any(launchdarkly_project.Example.Key),
			EnvKey:      pulumi.Any(launchdarkly_environment.Example.Key),
			Description: pulumi.String("This segment is managed by Terraform"),
			Tags: pulumi.StringArray{
				pulumi.String("segment-tag-1"),
				pulumi.String("segment-tag-2"),
			},
			Includeds: pulumi.StringArray{
				pulumi.String("user1"),
				pulumi.String("user2"),
			},
			Excludeds: pulumi.StringArray{
				pulumi.String("user3"),
				pulumi.String("user4"),
			},
			Rules: launchdarkly.SegmentRuleArray{
				&launchdarkly.SegmentRuleArgs{
					Clauses: launchdarkly.SegmentRuleClauseArray{
						&launchdarkly.SegmentRuleClauseArgs{
							Attribute: pulumi.String("country"),
							Op:        pulumi.String("startsWith"),
							Values: pulumi.StringArray{
								pulumi.String("en"),
								pulumi.String("de"),
								pulumi.String("un"),
							},
							Negate: pulumi.Bool(false),
						},
					},
				},
			},
		})
		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.Segment;
import com.pulumi.launchdarkly.SegmentArgs;
import com.pulumi.launchdarkly.inputs.SegmentRuleArgs;
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 Segment("example", SegmentArgs.builder()        
            .key("example-segment-key")
            .projectKey(launchdarkly_project.example().key())
            .envKey(launchdarkly_environment.example().key())
            .description("This segment is managed by Terraform")
            .tags(            
                "segment-tag-1",
                "segment-tag-2")
            .includeds(            
                "user1",
                "user2")
            .excludeds(            
                "user3",
                "user4")
            .rules(SegmentRuleArgs.builder()
                .clauses(SegmentRuleClauseArgs.builder()
                    .attribute("country")
                    .op("startsWith")
                    .values(                    
                        "en",
                        "de",
                        "un")
                    .negate(false)
                    .build())
                .build())
            .build());

    }
}

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

const example = new launchdarkly.Segment("example", {
    key: "example-segment-key",
    projectKey: launchdarkly_project.example.key,
    envKey: launchdarkly_environment.example.key,
    description: "This segment is managed by Terraform",
    tags: [
        "segment-tag-1",
        "segment-tag-2",
    ],
    includeds: [
        "user1",
        "user2",
    ],
    excludeds: [
        "user3",
        "user4",
    ],
    rules: [{
        clauses: [{
            attribute: "country",
            op: "startsWith",
            values: [
                "en",
                "de",
                "un",
            ],
            negate: false,
        }],
    }],
});

import pulumi
import lbrlabs_pulumi_launchdarkly as launchdarkly

example = launchdarkly.Segment("example",
    key="example-segment-key",
    project_key=launchdarkly_project["example"]["key"],
    env_key=launchdarkly_environment["example"]["key"],
    description="This segment is managed by Terraform",
    tags=[
        "segment-tag-1",
        "segment-tag-2",
    ],
    includeds=[
        "user1",
        "user2",
    ],
    excludeds=[
        "user3",
        "user4",
    ],
    rules=[launchdarkly.SegmentRuleArgs(
        clauses=[launchdarkly.SegmentRuleClauseArgs(
            attribute="country",
            op="startsWith",
            values=[
                "en",
                "de",
                "un",
            ],
            negate=False,
        )],
    )])

resources:
  example:
    type: launchdarkly:Segment
    properties:
      key: example-segment-key
      projectKey: ${launchdarkly_project.example.key}
      envKey: ${launchdarkly_environment.example.key}
      description: This segment is managed by Terraform
      tags:
        - segment-tag-1
        - segment-tag-2
      includeds:
        - user1
        - user2
      excludeds:
        - user3
        - user4
      rules:
        - clauses:
            - attribute: country
              op: startsWith
              values:
                - en
                - de
                - un
              negate: false