datadog.getDashboardList

using System.Collections.Generic;
using Pulumi;
using Datadog = Pulumi.Datadog;

return await Deployment.RunAsync(() => 
{
    var test = Datadog.GetDashboardList.Invoke(new()
    {
        Name = "My super list",
    });

    // Create a dashboard and register it in the list above.
    var time = new Datadog.Dashboard("time", new()
    {
        DashboardLists = new[]
        {
            test.Apply(getDashboardListResult => getDashboardListResult.Id),
        },
        Description = "Created using the Datadog provider in Terraform",
        IsReadOnly = true,
        LayoutType = "ordered",
        Title = "TF Test Layout Dashboard",
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "1234",
                    LiveSpan = "1h",
                    Title = "Widget Title",
                    VizType = "timeseries",
                },
            },
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		test, err := datadog.LookupDashboardList(ctx, &datadog.LookupDashboardListArgs{
			Name: "My super list",
		}, nil)
		if err != nil {
			return err
		}
		_, err = datadog.NewDashboard(ctx, "time", &datadog.DashboardArgs{
			DashboardLists: pulumi.IntArray{
				*pulumi.String(test.Id),
			},
			Description: pulumi.String("Created using the Datadog provider in Terraform"),
			IsReadOnly:  pulumi.Bool(true),
			LayoutType:  pulumi.String("ordered"),
			Title:       pulumi.String("TF Test Layout Dashboard"),
			Widgets: datadog.DashboardWidgetArray{
				&datadog.DashboardWidgetArgs{
					AlertGraphDefinition: &datadog.DashboardWidgetAlertGraphDefinitionArgs{
						AlertId:  pulumi.String("1234"),
						LiveSpan: pulumi.String("1h"),
						Title:    pulumi.String("Widget Title"),
						VizType:  pulumi.String("timeseries"),
					},
				},
			},
		})
		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.datadog.DatadogFunctions;
import com.pulumi.datadog.inputs.GetDashboardListArgs;
import com.pulumi.datadog.Dashboard;
import com.pulumi.datadog.DashboardArgs;
import com.pulumi.datadog.inputs.DashboardWidgetArgs;
import com.pulumi.datadog.inputs.DashboardWidgetAlertGraphDefinitionArgs;
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) {
        final var test = DatadogFunctions.getDashboardList(GetDashboardListArgs.builder()
            .name("My super list")
            .build());

        var time = new Dashboard("time", DashboardArgs.builder()        
            .dashboardLists(test.applyValue(getDashboardListResult -> getDashboardListResult.id()))
            .description("Created using the Datadog provider in Terraform")
            .isReadOnly(true)
            .layoutType("ordered")
            .title("TF Test Layout Dashboard")
            .widgets(DashboardWidgetArgs.builder()
                .alertGraphDefinition(DashboardWidgetAlertGraphDefinitionArgs.builder()
                    .alertId("1234")
                    .liveSpan("1h")
                    .title("Widget Title")
                    .vizType("timeseries")
                    .build())
                .build())
            .build());

    }
}

import pulumi
import pulumi_datadog as datadog

test = datadog.get_dashboard_list(name="My super list")
# Create a dashboard and register it in the list above.
time = datadog.Dashboard("time",
    dashboard_lists=[test.id],
    description="Created using the Datadog provider in Terraform",
    is_read_only=True,
    layout_type="ordered",
    title="TF Test Layout Dashboard",
    widgets=[datadog.DashboardWidgetArgs(
        alert_graph_definition=datadog.DashboardWidgetAlertGraphDefinitionArgs(
            alert_id="1234",
            live_span="1h",
            title="Widget Title",
            viz_type="timeseries",
        ),
    )])

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

const test = datadog.getDashboardList({
    name: "My super list",
});
// Create a dashboard and register it in the list above.
const time = new datadog.Dashboard("time", {
    dashboardLists: [test.then(test => test.id)],
    description: "Created using the Datadog provider in Terraform",
    isReadOnly: true,
    layoutType: "ordered",
    title: "TF Test Layout Dashboard",
    widgets: [{
        alertGraphDefinition: {
            alertId: "1234",
            liveSpan: "1h",
            title: "Widget Title",
            vizType: "timeseries",
        },
    }],
});

resources:
  # Create a dashboard and register it in the list above.
  time:
    type: datadog:Dashboard
    properties:
      dashboardLists:
        - ${test.id}
      description: Created using the Datadog provider in Terraform
      isReadOnly: true
      layoutType: ordered
      title: TF Test Layout Dashboard
      widgets:
        - alertGraphDefinition:
            alertId: '1234'
            liveSpan: 1h
            title: Widget Title
            vizType: timeseries
variables:
  test:
    fn::invoke:
      Function: datadog:getDashboardList
      Arguments:
        name: My super list