datadog.getDashboardList

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", {
    title: "TF Test Layout Dashboard",
    description: "Created using the Datadog provider in Pulumi",
    dashboardLists: [test.then(test => test.id)],
    layoutType: "ordered",
    isReadOnly: true,
    widgets: [{
        alertGraphDefinition: {
            alertId: "1234",
            vizType: "timeseries",
            title: "Widget Title",
            liveSpan: "1h",
        },
    }],
});

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",
    title="TF Test Layout Dashboard",
    description="Created using the Datadog provider in Pulumi",
    dashboard_lists=[test.id],
    layout_type="ordered",
    is_read_only=True,
    widgets=[{
        "alert_graph_definition": {
            "alert_id": "1234",
            "viz_type": "timeseries",
            "title": "Widget Title",
            "live_span": "1h",
        },
    }])

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
		}
		// Create a dashboard and register it in the list above.
		_, err = datadog.NewDashboard(ctx, "time", &datadog.DashboardArgs{
			Title:       pulumi.String("TF Test Layout Dashboard"),
			Description: pulumi.String("Created using the Datadog provider in Pulumi"),
			DashboardLists: pulumi.IntArray{
				pulumi.String(test.Id),
			},
			LayoutType: pulumi.String("ordered"),
			IsReadOnly: pulumi.Bool(true),
			Widgets: datadog.DashboardWidgetArray{
				&datadog.DashboardWidgetArgs{
					AlertGraphDefinition: &datadog.DashboardWidgetAlertGraphDefinitionArgs{
						AlertId:  pulumi.String("1234"),
						VizType:  pulumi.String("timeseries"),
						Title:    pulumi.String("Widget Title"),
						LiveSpan: pulumi.String("1h"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
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()
    {
        Title = "TF Test Layout Dashboard",
        Description = "Created using the Datadog provider in Pulumi",
        DashboardLists = new[]
        {
            test.Apply(getDashboardListResult => getDashboardListResult.Id),
        },
        LayoutType = "ordered",
        IsReadOnly = true,
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "1234",
                    VizType = "timeseries",
                    Title = "Widget Title",
                    LiveSpan = "1h",
                },
            },
        },
    });

});

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());

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

    }
}

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

function getDashboardList(args: GetDashboardListArgs, opts?: InvokeOptions): Promise<GetDashboardListResult>
function getDashboardListOutput(args: GetDashboardListOutputArgs, opts?: InvokeOptions): Output<GetDashboardListResult>

def get_dashboard_list(name: Optional[str] = None,
                       opts: Optional[InvokeOptions] = None) -> GetDashboardListResult
def get_dashboard_list_output(name: Optional[pulumi.Input[str]] = None,
                       opts: Optional[InvokeOptions] = None) -> Output[GetDashboardListResult]

func LookupDashboardList(ctx *Context, args *LookupDashboardListArgs, opts ...InvokeOption) (*LookupDashboardListResult, error)
func LookupDashboardListOutput(ctx *Context, args *LookupDashboardListOutputArgs, opts ...InvokeOption) LookupDashboardListResultOutput

public static class GetDashboardList 
{
    public static Task<GetDashboardListResult> InvokeAsync(GetDashboardListArgs args, InvokeOptions? opts = null)
    public static Output<GetDashboardListResult> Invoke(GetDashboardListInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDashboardListResult> getDashboardList(GetDashboardListArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: datadog:index/getDashboardList:getDashboardList
  arguments:
    # arguments dictionary