1. Packages
  2. Datadog
  3. API Docs
  4. Dashboard
Datadog v4.28.0 published on Tuesday, Apr 23, 2024 by Pulumi

datadog.Dashboard

Explore with Pulumi AI

datadog logo
Datadog v4.28.0 published on Tuesday, Apr 23, 2024 by Pulumi

    Provides a Datadog dashboard resource. This can be used to create and manage Datadog dashboards.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as datadog from "@pulumi/datadog";
    
    // Example Ordered Layout
    const orderedDashboard = new datadog.Dashboard("ordered_dashboard", {
        title: "Ordered Layout Dashboard",
        description: "Created using the Datadog provider in Pulumi",
        layoutType: "ordered",
        widgets: [
            {
                alertGraphDefinition: {
                    alertId: "895605",
                    vizType: "timeseries",
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                alertValueDefinition: {
                    alertId: "895605",
                    precision: 3,
                    unit: "b",
                    textAlign: "center",
                    title: "Widget Title",
                },
            },
            {
                alertValueDefinition: {
                    alertId: "895605",
                    precision: 3,
                    unit: "b",
                    textAlign: "center",
                    title: "Widget Title",
                },
            },
            {
                changeDefinition: {
                    requests: [{
                        q: "avg:system.load.1{env:staging} by {account}",
                        changeType: "absolute",
                        compareTo: "week_before",
                        increaseGood: true,
                        orderBy: "name",
                        orderDir: "desc",
                        showPresent: true,
                    }],
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                distributionDefinition: {
                    requests: [{
                        q: "avg:system.load.1{env:staging} by {account}",
                        style: {
                            palette: "warm",
                        },
                    }],
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                checkStatusDefinition: {
                    check: "aws.ecs.agent_connected",
                    grouping: "cluster",
                    groupBies: [
                        "account",
                        "cluster",
                    ],
                    tags: [
                        "account:demo",
                        "cluster:awseb-ruthebdog-env-8-dn3m6u3gvk",
                    ],
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                heatmapDefinition: {
                    requests: [{
                        q: "avg:system.load.1{env:staging} by {account}",
                        style: {
                            palette: "warm",
                        },
                    }],
                    yaxis: {
                        min: "1",
                        max: "2",
                        includeZero: true,
                        scale: "sqrt",
                    },
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                hostmapDefinition: {
                    request: {
                        fills: [{
                            q: "avg:system.load.1{*} by {host}",
                        }],
                        sizes: [{
                            q: "avg:memcache.uptime{*} by {host}",
                        }],
                    },
                    nodeType: "container",
                    groups: [
                        "host",
                        "region",
                    ],
                    noGroupHosts: true,
                    noMetricHosts: true,
                    scopes: [
                        "region:us-east-1",
                        "aws_account:727006795293",
                    ],
                    style: {
                        palette: "yellow_to_green",
                        paletteFlip: true,
                        fillMin: "10",
                        fillMax: "20",
                    },
                    title: "Widget Title",
                },
            },
            {
                noteDefinition: {
                    content: "note text",
                    backgroundColor: "pink",
                    fontSize: "14",
                    textAlign: "center",
                    showTick: true,
                    tickEdge: "left",
                    tickPos: "50%",
                },
            },
            {
                queryValueDefinition: {
                    requests: [{
                        q: "avg:system.load.1{env:staging} by {account}",
                        aggregator: "sum",
                        conditionalFormats: [
                            {
                                comparator: "<",
                                value: 2,
                                palette: "white_on_green",
                            },
                            {
                                comparator: ">",
                                value: 2.2,
                                palette: "white_on_red",
                            },
                        ],
                    }],
                    autoscale: true,
                    customUnit: "xx",
                    precision: 4,
                    textAlign: "right",
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                queryTableDefinition: {
                    requests: [{
                        q: "avg:system.load.1{env:staging} by {account}",
                        aggregator: "sum",
                        limit: 10,
                        conditionalFormats: [
                            {
                                comparator: "<",
                                value: 2,
                                palette: "white_on_green",
                            },
                            {
                                comparator: ">",
                                value: 2.2,
                                palette: "white_on_red",
                            },
                        ],
                    }],
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                scatterplotDefinition: {
                    request: {
                        xes: [{
                            q: "avg:system.cpu.user{*} by {service, account}",
                            aggregator: "max",
                        }],
                        ys: [{
                            q: "avg:system.mem.used{*} by {service, account}",
                            aggregator: "min",
                        }],
                    },
                    colorByGroups: [
                        "account",
                        "apm-role-group",
                    ],
                    xaxis: {
                        includeZero: true,
                        label: "x",
                        min: "1",
                        max: "2000",
                        scale: "pow",
                    },
                    yaxis: {
                        includeZero: false,
                        label: "y",
                        min: "5",
                        max: "2222",
                        scale: "log",
                    },
                    title: "Widget Title",
                    liveSpan: "1h",
                },
            },
            {
                servicemapDefinition: {
                    service: "master-db",
                    filters: [
                        "env:prod",
                        "datacenter:dc1",
                    ],
                    title: "env: prod, datacenter:dc1, service: master-db",
                    titleSize: "16",
                    titleAlign: "left",
                },
            },
            {
                timeseriesDefinition: {
                    requests: [
                        {
                            q: "avg:system.cpu.user{app:general} by {env}",
                            displayType: "line",
                            style: {
                                palette: "warm",
                                lineType: "dashed",
                                lineWidth: "thin",
                            },
                            metadatas: [{
                                expression: "avg:system.cpu.user{app:general} by {env}",
                                aliasName: "Alpha",
                            }],
                        },
                        {
                            logQuery: {
                                index: "mcnulty",
                                computeQuery: {
                                    aggregation: "avg",
                                    facet: "@duration",
                                    interval: 5000,
                                },
                                searchQuery: "status:info",
                                groupBies: [{
                                    facet: "host",
                                    limit: 10,
                                    sortQuery: {
                                        aggregation: "avg",
                                        order: "desc",
                                        facet: "@duration",
                                    },
                                }],
                            },
                            displayType: "area",
                        },
                        {
                            apmQuery: {
                                index: "apm-search",
                                computeQuery: {
                                    aggregation: "avg",
                                    facet: "@duration",
                                    interval: 5000,
                                },
                                searchQuery: "type:web",
                                groupBies: [{
                                    facet: "resource_name",
                                    limit: 50,
                                    sortQuery: {
                                        aggregation: "avg",
                                        order: "desc",
                                        facet: "@string_query.interval",
                                    },
                                }],
                            },
                            displayType: "bars",
                        },
                        {
                            processQuery: {
                                metric: "process.stat.cpu.total_pct",
                                searchBy: "error",
                                filterBies: ["active"],
                                limit: 50,
                            },
                            displayType: "area",
                        },
                    ],
                    markers: [
                        {
                            displayType: "error dashed",
                            label: " z=6 ",
                            value: "y = 4",
                        },
                        {
                            displayType: "ok solid",
                            value: "10 < y < 999",
                            label: " x=8 ",
                        },
                    ],
                    title: "Widget Title",
                    showLegend: true,
                    legendSize: "2",
                    liveSpan: "1h",
                    events: [
                        {
                            q: "sources:test tags:1",
                        },
                        {
                            q: "sources:test tags:2",
                        },
                    ],
                    yaxis: {
                        scale: "log",
                        includeZero: false,
                        max: "100",
                    },
                },
            },
            {
                toplistDefinition: {
                    requests: [{
                        q: "avg:system.cpu.user{app:general} by {env}",
                        conditionalFormats: [
                            {
                                comparator: "<",
                                value: 2,
                                palette: "white_on_green",
                            },
                            {
                                comparator: ">",
                                value: 2.2,
                                palette: "white_on_red",
                            },
                        ],
                    }],
                    title: "Widget Title",
                },
            },
            {
                groupDefinition: {
                    layoutType: "ordered",
                    title: "Group Widget",
                    widgets: [
                        {
                            noteDefinition: {
                                content: "cluster note widget",
                                backgroundColor: "pink",
                                fontSize: "14",
                                textAlign: "center",
                                showTick: true,
                                tickEdge: "left",
                                tickPos: "50%",
                            },
                        },
                        {
                            alertGraphDefinition: {
                                alertId: "123",
                                vizType: "toplist",
                                title: "Alert Graph",
                                liveSpan: "1h",
                            },
                        },
                    ],
                },
            },
            {
                serviceLevelObjectiveDefinition: {
                    title: "Widget Title",
                    viewType: "detail",
                    sloId: "56789",
                    showErrorBudget: true,
                    viewMode: "overall",
                    timeWindows: [
                        "7d",
                        "previous_week",
                    ],
                },
            },
        ],
        templateVariables: [
            {
                name: "var_1",
                prefix: "host",
                "default": "aws",
            },
            {
                name: "var_2",
                prefix: "service_name",
                "default": "autoscaling",
            },
        ],
        templateVariablePresets: [{
            name: "preset_1",
            templateVariables: [
                {
                    name: "var_1",
                    value: "host.dc",
                },
                {
                    name: "var_2",
                    value: "my_service",
                },
            ],
        }],
    });
    // Example Free Layout
    const freeDashboard = new datadog.Dashboard("free_dashboard", {
        title: "Free Layout Dashboard",
        description: "Created using the Datadog provider in Pulumi",
        layoutType: "free",
        widgets: [
            {
                eventStreamDefinition: {
                    query: "*",
                    eventSize: "l",
                    title: "Widget Title",
                    titleSize: "16",
                    titleAlign: "left",
                    liveSpan: "1h",
                },
                widgetLayout: {
                    height: 43,
                    width: 32,
                    x: 0,
                    y: 0,
                },
            },
            {
                eventTimelineDefinition: {
                    query: "*",
                    title: "Widget Title",
                    titleSize: "16",
                    titleAlign: "left",
                    liveSpan: "1h",
                },
                widgetLayout: {
                    height: 9,
                    width: 66,
                    x: 33,
                    y: 60,
                },
            },
            {
                freeTextDefinition: {
                    text: "free text content",
                    color: "#d00",
                    fontSize: "36",
                    textAlign: "left",
                },
                widgetLayout: {
                    height: 20,
                    width: 34,
                    x: 33,
                    y: 0,
                },
            },
            {
                iframeDefinition: {
                    url: "http://google.com",
                },
                widgetLayout: {
                    height: 46,
                    width: 39,
                    x: 101,
                    y: 0,
                },
            },
            {
                imageDefinition: {
                    url: "https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350",
                    sizing: "fit",
                    margin: "small",
                },
                widgetLayout: {
                    height: 20,
                    width: 30,
                    x: 69,
                    y: 0,
                },
            },
            {
                logStreamDefinition: {
                    indexes: ["main"],
                    query: "error",
                    columns: [
                        "core_host",
                        "core_service",
                        "tag_source",
                    ],
                    showDateColumn: true,
                    showMessageColumn: true,
                    messageDisplay: "expanded-md",
                    sort: {
                        column: "time",
                        order: "desc",
                    },
                },
                widgetLayout: {
                    height: 36,
                    width: 32,
                    x: 0,
                    y: 45,
                },
            },
            {
                manageStatusDefinition: {
                    colorPreference: "text",
                    displayFormat: "countsAndList",
                    hideZeroCounts: true,
                    query: "type:metric",
                    showLastTriggered: false,
                    sort: "status,asc",
                    summaryType: "monitors",
                    title: "Widget Title",
                    titleSize: "16",
                    titleAlign: "left",
                },
                widgetLayout: {
                    height: 40,
                    width: 30,
                    x: 101,
                    y: 48,
                },
            },
            {
                traceServiceDefinition: {
                    displayFormat: "three_column",
                    env: "datadog.com",
                    service: "alerting-cassandra",
                    showBreakdown: true,
                    showDistribution: true,
                    showErrors: true,
                    showHits: true,
                    showLatency: false,
                    showResourceList: false,
                    sizeFormat: "large",
                    spanName: "cassandra.query",
                    title: "alerting-cassandra #env:datadog.com",
                    titleAlign: "center",
                    titleSize: "13",
                    liveSpan: "1h",
                },
                widgetLayout: {
                    height: 38,
                    width: 66,
                    x: 33,
                    y: 21,
                },
            },
            {
                timeseriesDefinition: {
                    requests: [{
                        formulas: [
                            {
                                formulaExpression: "my_query_1 + my_query_2",
                                alias: "my ff query",
                            },
                            {
                                formulaExpression: "my_query_1 * my_query_2",
                                limit: {
                                    count: 5,
                                    order: "desc",
                                },
                                alias: "my second ff query",
                            },
                        ],
                        queries: [
                            {
                                metricQuery: {
                                    dataSource: "metrics",
                                    query: "avg:system.cpu.user{app:general} by {env}",
                                    name: "my_query_1",
                                    aggregator: "sum",
                                },
                            },
                            {
                                metricQuery: {
                                    query: "avg:system.cpu.user{app:general} by {env}",
                                    name: "my_query_2",
                                    aggregator: "sum",
                                },
                            },
                        ],
                    }],
                },
                widgetLayout: {
                    height: 16,
                    width: 25,
                    x: 58,
                    y: 83,
                },
            },
            {
                timeseriesDefinition: {
                    requests: [
                        {
                            queries: [{
                                eventQuery: {
                                    name: "my-query",
                                    dataSource: "logs",
                                    indexes: ["days-3"],
                                    computes: [{
                                        aggregation: "count",
                                    }],
                                    groupBies: [{
                                        facet: "host",
                                        sort: {
                                            metric: "@lambda.max_memory_used",
                                            aggregation: "avg",
                                        },
                                        limit: 10,
                                    }],
                                },
                            }],
                        },
                        {
                            displayType: "overlay",
                            queries: [{
                                metricQuery: {
                                    name: "MyOverlay",
                                    dataSource: "metrics",
                                    query: "avg:system.cpu.user{host:COMP-QJWVM2FYT4}",
                                },
                            }],
                        },
                    ],
                },
                widgetLayout: {
                    height: 16,
                    width: 28,
                    x: 29,
                    y: 83,
                },
            },
            {
                timeseriesDefinition: {
                    requests: [{
                        queries: [{
                            processQuery: {
                                dataSource: "process",
                                textFilter: "abc",
                                metric: "process.stat.cpu.total_pct",
                                limit: 10,
                                tagFilters: ["some_filter"],
                                name: "my_process_query",
                                sort: "asc",
                                isNormalizedCpu: true,
                                aggregator: "sum",
                            },
                        }],
                    }],
                },
                widgetLayout: {
                    height: 16,
                    width: 28,
                    x: 0,
                    y: 83,
                },
            },
            {
                timeseriesDefinition: {
                    requests: [{
                        formulas: [{
                            formulaExpression: "query1",
                            alias: "my cloud cost query",
                        }],
                        queries: [{
                            cloudCostQuery: {
                                dataSource: "cloud_cost",
                                query: "sum:aws.cost.amortized{*}",
                                name: "query1",
                                aggregator: "sum",
                            },
                        }],
                    }],
                },
            },
            {
                powerpackDefinition: {
                    powerpackId: "00000000-0000-0000-0000-000000000000",
                    backgroundColor: "blue",
                    bannerImg: "https://example.org/example.png",
                    showTitle: true,
                    title: "Powerpack Widget",
                    templateVariables: {
                        controlledExternallies: [{
                            name: "var_2",
                            values: ["autoscaling"],
                            prefix: "service_name",
                        }],
                        controlledByPowerpacks: [{
                            name: "var_3",
                            prefix: "timeframe",
                            values: [
                                "default",
                                "values",
                                "here",
                            ],
                        }],
                    },
                },
            },
        ],
        templateVariables: [
            {
                name: "var_1",
                prefix: "host",
                "default": "aws",
            },
            {
                name: "var_2",
                prefix: "service_name",
                "default": "autoscaling",
            },
        ],
        templateVariablePresets: [{
            name: "preset_1",
            templateVariables: [
                {
                    name: "var_1",
                    value: "host.dc",
                },
                {
                    name: "var_2",
                    value: "my_service",
                },
            ],
        }],
    });
    
    import pulumi
    import pulumi_datadog as datadog
    
    # Example Ordered Layout
    ordered_dashboard = datadog.Dashboard("ordered_dashboard",
        title="Ordered Layout Dashboard",
        description="Created using the Datadog provider in Pulumi",
        layout_type="ordered",
        widgets=[
            datadog.DashboardWidgetArgs(
                alert_graph_definition=datadog.DashboardWidgetAlertGraphDefinitionArgs(
                    alert_id="895605",
                    viz_type="timeseries",
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                alert_value_definition=datadog.DashboardWidgetAlertValueDefinitionArgs(
                    alert_id="895605",
                    precision=3,
                    unit="b",
                    text_align="center",
                    title="Widget Title",
                ),
            ),
            datadog.DashboardWidgetArgs(
                alert_value_definition=datadog.DashboardWidgetAlertValueDefinitionArgs(
                    alert_id="895605",
                    precision=3,
                    unit="b",
                    text_align="center",
                    title="Widget Title",
                ),
            ),
            datadog.DashboardWidgetArgs(
                change_definition=datadog.DashboardWidgetChangeDefinitionArgs(
                    requests=[datadog.DashboardWidgetChangeDefinitionRequestArgs(
                        q="avg:system.load.1{env:staging} by {account}",
                        change_type="absolute",
                        compare_to="week_before",
                        increase_good=True,
                        order_by="name",
                        order_dir="desc",
                        show_present=True,
                    )],
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                distribution_definition=datadog.DashboardWidgetDistributionDefinitionArgs(
                    requests=[datadog.DashboardWidgetDistributionDefinitionRequestArgs(
                        q="avg:system.load.1{env:staging} by {account}",
                        style=datadog.DashboardWidgetDistributionDefinitionRequestStyleArgs(
                            palette="warm",
                        ),
                    )],
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                check_status_definition=datadog.DashboardWidgetCheckStatusDefinitionArgs(
                    check="aws.ecs.agent_connected",
                    grouping="cluster",
                    group_bies=[
                        "account",
                        "cluster",
                    ],
                    tags=[
                        "account:demo",
                        "cluster:awseb-ruthebdog-env-8-dn3m6u3gvk",
                    ],
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                heatmap_definition=datadog.DashboardWidgetHeatmapDefinitionArgs(
                    requests=[datadog.DashboardWidgetHeatmapDefinitionRequestArgs(
                        q="avg:system.load.1{env:staging} by {account}",
                        style=datadog.DashboardWidgetHeatmapDefinitionRequestStyleArgs(
                            palette="warm",
                        ),
                    )],
                    yaxis=datadog.DashboardWidgetHeatmapDefinitionYaxisArgs(
                        min="1",
                        max="2",
                        include_zero=True,
                        scale="sqrt",
                    ),
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                hostmap_definition=datadog.DashboardWidgetHostmapDefinitionArgs(
                    request=datadog.DashboardWidgetHostmapDefinitionRequestArgs(
                        fills=[datadog.DashboardWidgetHostmapDefinitionRequestFillArgs(
                            q="avg:system.load.1{*} by {host}",
                        )],
                        sizes=[datadog.DashboardWidgetHostmapDefinitionRequestSizeArgs(
                            q="avg:memcache.uptime{*} by {host}",
                        )],
                    ),
                    node_type="container",
                    groups=[
                        "host",
                        "region",
                    ],
                    no_group_hosts=True,
                    no_metric_hosts=True,
                    scopes=[
                        "region:us-east-1",
                        "aws_account:727006795293",
                    ],
                    style=datadog.DashboardWidgetHostmapDefinitionStyleArgs(
                        palette="yellow_to_green",
                        palette_flip=True,
                        fill_min="10",
                        fill_max="20",
                    ),
                    title="Widget Title",
                ),
            ),
            datadog.DashboardWidgetArgs(
                note_definition=datadog.DashboardWidgetNoteDefinitionArgs(
                    content="note text",
                    background_color="pink",
                    font_size="14",
                    text_align="center",
                    show_tick=True,
                    tick_edge="left",
                    tick_pos="50%",
                ),
            ),
            datadog.DashboardWidgetArgs(
                query_value_definition=datadog.DashboardWidgetQueryValueDefinitionArgs(
                    requests=[datadog.DashboardWidgetQueryValueDefinitionRequestArgs(
                        q="avg:system.load.1{env:staging} by {account}",
                        aggregator="sum",
                        conditional_formats=[
                            datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs(
                                comparator="<",
                                value=2,
                                palette="white_on_green",
                            ),
                            datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs(
                                comparator=">",
                                value=2.2,
                                palette="white_on_red",
                            ),
                        ],
                    )],
                    autoscale=True,
                    custom_unit="xx",
                    precision=4,
                    text_align="right",
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                query_table_definition=datadog.DashboardWidgetQueryTableDefinitionArgs(
                    requests=[datadog.DashboardWidgetQueryTableDefinitionRequestArgs(
                        q="avg:system.load.1{env:staging} by {account}",
                        aggregator="sum",
                        limit=10,
                        conditional_formats=[
                            datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs(
                                comparator="<",
                                value=2,
                                palette="white_on_green",
                            ),
                            datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs(
                                comparator=">",
                                value=2.2,
                                palette="white_on_red",
                            ),
                        ],
                    )],
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                scatterplot_definition=datadog.DashboardWidgetScatterplotDefinitionArgs(
                    request=datadog.DashboardWidgetScatterplotDefinitionRequestArgs(
                        xes=[datadog.DashboardWidgetScatterplotDefinitionRequestXArgs(
                            q="avg:system.cpu.user{*} by {service, account}",
                            aggregator="max",
                        )],
                        ys=[datadog.DashboardWidgetScatterplotDefinitionRequestYArgs(
                            q="avg:system.mem.used{*} by {service, account}",
                            aggregator="min",
                        )],
                    ),
                    color_by_groups=[
                        "account",
                        "apm-role-group",
                    ],
                    xaxis=datadog.DashboardWidgetScatterplotDefinitionXaxisArgs(
                        include_zero=True,
                        label="x",
                        min="1",
                        max="2000",
                        scale="pow",
                    ),
                    yaxis=datadog.DashboardWidgetScatterplotDefinitionYaxisArgs(
                        include_zero=False,
                        label="y",
                        min="5",
                        max="2222",
                        scale="log",
                    ),
                    title="Widget Title",
                    live_span="1h",
                ),
            ),
            datadog.DashboardWidgetArgs(
                servicemap_definition=datadog.DashboardWidgetServicemapDefinitionArgs(
                    service="master-db",
                    filters=[
                        "env:prod",
                        "datacenter:dc1",
                    ],
                    title="env: prod, datacenter:dc1, service: master-db",
                    title_size="16",
                    title_align="left",
                ),
            ),
            datadog.DashboardWidgetArgs(
                timeseries_definition=datadog.DashboardWidgetTimeseriesDefinitionArgs(
                    requests=[
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            q="avg:system.cpu.user{app:general} by {env}",
                            display_type="line",
                            style=datadog.DashboardWidgetTimeseriesDefinitionRequestStyleArgs(
                                palette="warm",
                                line_type="dashed",
                                line_width="thin",
                            ),
                            metadatas=[datadog.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs(
                                expression="avg:system.cpu.user{app:general} by {env}",
                                alias_name="Alpha",
                            )],
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            log_query=datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryArgs(
                                index="mcnulty",
                                compute_query=datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryComputeQueryArgs(
                                    aggregation="avg",
                                    facet="@duration",
                                    interval=5000,
                                ),
                                search_query="status:info",
                                group_bies=[datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupByArgs(
                                    facet="host",
                                    limit=10,
                                    sort_query=datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupBySortQueryArgs(
                                        aggregation="avg",
                                        order="desc",
                                        facet="@duration",
                                    ),
                                )],
                            ),
                            display_type="area",
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            apm_query=datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryArgs(
                                index="apm-search",
                                compute_query=datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryComputeQueryArgs(
                                    aggregation="avg",
                                    facet="@duration",
                                    interval=5000,
                                ),
                                search_query="type:web",
                                group_bies=[datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupByArgs(
                                    facet="resource_name",
                                    limit=50,
                                    sort_query=datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupBySortQueryArgs(
                                        aggregation="avg",
                                        order="desc",
                                        facet="@string_query.interval",
                                    ),
                                )],
                            ),
                            display_type="bars",
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            process_query=datadog.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs(
                                metric="process.stat.cpu.total_pct",
                                search_by="error",
                                filter_bies=["active"],
                                limit=50,
                            ),
                            display_type="area",
                        ),
                    ],
                    markers=[
                        datadog.DashboardWidgetTimeseriesDefinitionMarkerArgs(
                            display_type="error dashed",
                            label=" z=6 ",
                            value="y = 4",
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionMarkerArgs(
                            display_type="ok solid",
                            value="10 < y < 999",
                            label=" x=8 ",
                        ),
                    ],
                    title="Widget Title",
                    show_legend=True,
                    legend_size="2",
                    live_span="1h",
                    events=[
                        datadog.DashboardWidgetTimeseriesDefinitionEventArgs(
                            q="sources:test tags:1",
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionEventArgs(
                            q="sources:test tags:2",
                        ),
                    ],
                    yaxis=datadog.DashboardWidgetTimeseriesDefinitionYaxisArgs(
                        scale="log",
                        include_zero=False,
                        max="100",
                    ),
                ),
            ),
            datadog.DashboardWidgetArgs(
                toplist_definition=datadog.DashboardWidgetToplistDefinitionArgs(
                    requests=[datadog.DashboardWidgetToplistDefinitionRequestArgs(
                        q="avg:system.cpu.user{app:general} by {env}",
                        conditional_formats=[
                            datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs(
                                comparator="<",
                                value=2,
                                palette="white_on_green",
                            ),
                            datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs(
                                comparator=">",
                                value=2.2,
                                palette="white_on_red",
                            ),
                        ],
                    )],
                    title="Widget Title",
                ),
            ),
            datadog.DashboardWidgetArgs(
                group_definition=datadog.DashboardWidgetGroupDefinitionArgs(
                    layout_type="ordered",
                    title="Group Widget",
                    widgets=[
                        datadog.DashboardWidgetGroupDefinitionWidgetArgs(
                            note_definition=datadog.DashboardWidgetGroupDefinitionWidgetNoteDefinitionArgs(
                                content="cluster note widget",
                                background_color="pink",
                                font_size="14",
                                text_align="center",
                                show_tick=True,
                                tick_edge="left",
                                tick_pos="50%",
                            ),
                        ),
                        datadog.DashboardWidgetGroupDefinitionWidgetArgs(
                            alert_graph_definition=datadog.DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs(
                                alert_id="123",
                                viz_type="toplist",
                                title="Alert Graph",
                                live_span="1h",
                            ),
                        ),
                    ],
                ),
            ),
            datadog.DashboardWidgetArgs(
                service_level_objective_definition=datadog.DashboardWidgetServiceLevelObjectiveDefinitionArgs(
                    title="Widget Title",
                    view_type="detail",
                    slo_id="56789",
                    show_error_budget=True,
                    view_mode="overall",
                    time_windows=[
                        "7d",
                        "previous_week",
                    ],
                ),
            ),
        ],
        template_variables=[
            datadog.DashboardTemplateVariableArgs(
                name="var_1",
                prefix="host",
                default="aws",
            ),
            datadog.DashboardTemplateVariableArgs(
                name="var_2",
                prefix="service_name",
                default="autoscaling",
            ),
        ],
        template_variable_presets=[datadog.DashboardTemplateVariablePresetArgs(
            name="preset_1",
            template_variables=[
                datadog.DashboardTemplateVariablePresetTemplateVariableArgs(
                    name="var_1",
                    value="host.dc",
                ),
                datadog.DashboardTemplateVariablePresetTemplateVariableArgs(
                    name="var_2",
                    value="my_service",
                ),
            ],
        )])
    # Example Free Layout
    free_dashboard = datadog.Dashboard("free_dashboard",
        title="Free Layout Dashboard",
        description="Created using the Datadog provider in Pulumi",
        layout_type="free",
        widgets=[
            datadog.DashboardWidgetArgs(
                event_stream_definition=datadog.DashboardWidgetEventStreamDefinitionArgs(
                    query="*",
                    event_size="l",
                    title="Widget Title",
                    title_size="16",
                    title_align="left",
                    live_span="1h",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=43,
                    width=32,
                    x=0,
                    y=0,
                ),
            ),
            datadog.DashboardWidgetArgs(
                event_timeline_definition=datadog.DashboardWidgetEventTimelineDefinitionArgs(
                    query="*",
                    title="Widget Title",
                    title_size="16",
                    title_align="left",
                    live_span="1h",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=9,
                    width=66,
                    x=33,
                    y=60,
                ),
            ),
            datadog.DashboardWidgetArgs(
                free_text_definition=datadog.DashboardWidgetFreeTextDefinitionArgs(
                    text="free text content",
                    color="#d00",
                    font_size="36",
                    text_align="left",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=20,
                    width=34,
                    x=33,
                    y=0,
                ),
            ),
            datadog.DashboardWidgetArgs(
                iframe_definition=datadog.DashboardWidgetIframeDefinitionArgs(
                    url="http://google.com",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=46,
                    width=39,
                    x=101,
                    y=0,
                ),
            ),
            datadog.DashboardWidgetArgs(
                image_definition=datadog.DashboardWidgetImageDefinitionArgs(
                    url="https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350",
                    sizing="fit",
                    margin="small",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=20,
                    width=30,
                    x=69,
                    y=0,
                ),
            ),
            datadog.DashboardWidgetArgs(
                log_stream_definition=datadog.DashboardWidgetLogStreamDefinitionArgs(
                    indexes=["main"],
                    query="error",
                    columns=[
                        "core_host",
                        "core_service",
                        "tag_source",
                    ],
                    show_date_column=True,
                    show_message_column=True,
                    message_display="expanded-md",
                    sort=datadog.DashboardWidgetLogStreamDefinitionSortArgs(
                        column="time",
                        order="desc",
                    ),
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=36,
                    width=32,
                    x=0,
                    y=45,
                ),
            ),
            datadog.DashboardWidgetArgs(
                manage_status_definition=datadog.DashboardWidgetManageStatusDefinitionArgs(
                    color_preference="text",
                    display_format="countsAndList",
                    hide_zero_counts=True,
                    query="type:metric",
                    show_last_triggered=False,
                    sort="status,asc",
                    summary_type="monitors",
                    title="Widget Title",
                    title_size="16",
                    title_align="left",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=40,
                    width=30,
                    x=101,
                    y=48,
                ),
            ),
            datadog.DashboardWidgetArgs(
                trace_service_definition=datadog.DashboardWidgetTraceServiceDefinitionArgs(
                    display_format="three_column",
                    env="datadog.com",
                    service="alerting-cassandra",
                    show_breakdown=True,
                    show_distribution=True,
                    show_errors=True,
                    show_hits=True,
                    show_latency=False,
                    show_resource_list=False,
                    size_format="large",
                    span_name="cassandra.query",
                    title="alerting-cassandra #env:datadog.com",
                    title_align="center",
                    title_size="13",
                    live_span="1h",
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=38,
                    width=66,
                    x=33,
                    y=21,
                ),
            ),
            datadog.DashboardWidgetArgs(
                timeseries_definition=datadog.DashboardWidgetTimeseriesDefinitionArgs(
                    requests=[datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                        formulas=[
                            datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs(
                                formula_expression="my_query_1 + my_query_2",
                                alias="my ff query",
                            ),
                            datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs(
                                formula_expression="my_query_1 * my_query_2",
                                limit=datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs(
                                    count=5,
                                    order="desc",
                                ),
                                alias="my second ff query",
                            ),
                        ],
                        queries=[
                            datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                                metric_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs(
                                    data_source="metrics",
                                    query="avg:system.cpu.user{app:general} by {env}",
                                    name="my_query_1",
                                    aggregator="sum",
                                ),
                            ),
                            datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                                metric_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs(
                                    query="avg:system.cpu.user{app:general} by {env}",
                                    name="my_query_2",
                                    aggregator="sum",
                                ),
                            ),
                        ],
                    )],
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=16,
                    width=25,
                    x=58,
                    y=83,
                ),
            ),
            datadog.DashboardWidgetArgs(
                timeseries_definition=datadog.DashboardWidgetTimeseriesDefinitionArgs(
                    requests=[
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            queries=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                                event_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs(
                                    name="my-query",
                                    data_source="logs",
                                    indexes=["days-3"],
                                    computes=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs(
                                        aggregation="count",
                                    )],
                                    group_bies=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs(
                                        facet="host",
                                        sort=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs(
                                            metric="@lambda.max_memory_used",
                                            aggregation="avg",
                                        ),
                                        limit=10,
                                    )],
                                ),
                            )],
                        ),
                        datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                            display_type="overlay",
                            queries=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                                metric_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs(
                                    name="MyOverlay",
                                    data_source="metrics",
                                    query="avg:system.cpu.user{host:COMP-QJWVM2FYT4}",
                                ),
                            )],
                        ),
                    ],
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=16,
                    width=28,
                    x=29,
                    y=83,
                ),
            ),
            datadog.DashboardWidgetArgs(
                timeseries_definition=datadog.DashboardWidgetTimeseriesDefinitionArgs(
                    requests=[datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                        queries=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                            process_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs(
                                data_source="process",
                                text_filter="abc",
                                metric="process.stat.cpu.total_pct",
                                limit=10,
                                tag_filters=["some_filter"],
                                name="my_process_query",
                                sort="asc",
                                is_normalized_cpu=True,
                                aggregator="sum",
                            ),
                        )],
                    )],
                ),
                widget_layout=datadog.DashboardWidgetWidgetLayoutArgs(
                    height=16,
                    width=28,
                    x=0,
                    y=83,
                ),
            ),
            datadog.DashboardWidgetArgs(
                timeseries_definition=datadog.DashboardWidgetTimeseriesDefinitionArgs(
                    requests=[datadog.DashboardWidgetTimeseriesDefinitionRequestArgs(
                        formulas=[datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs(
                            formula_expression="query1",
                            alias="my cloud cost query",
                        )],
                        queries=[datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs(
                            cloud_cost_query=datadog.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs(
                                data_source="cloud_cost",
                                query="sum:aws.cost.amortized{*}",
                                name="query1",
                                aggregator="sum",
                            ),
                        )],
                    )],
                ),
            ),
            datadog.DashboardWidgetArgs(
                powerpack_definition=datadog.DashboardWidgetPowerpackDefinitionArgs(
                    powerpack_id="00000000-0000-0000-0000-000000000000",
                    background_color="blue",
                    banner_img="https://example.org/example.png",
                    show_title=True,
                    title="Powerpack Widget",
                    template_variables=datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs(
                        controlled_externallies=[datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs(
                            name="var_2",
                            values=["autoscaling"],
                            prefix="service_name",
                        )],
                        controlled_by_powerpacks=[datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs(
                            name="var_3",
                            prefix="timeframe",
                            values=[
                                "default",
                                "values",
                                "here",
                            ],
                        )],
                    ),
                ),
            ),
        ],
        template_variables=[
            datadog.DashboardTemplateVariableArgs(
                name="var_1",
                prefix="host",
                default="aws",
            ),
            datadog.DashboardTemplateVariableArgs(
                name="var_2",
                prefix="service_name",
                default="autoscaling",
            ),
        ],
        template_variable_presets=[datadog.DashboardTemplateVariablePresetArgs(
            name="preset_1",
            template_variables=[
                datadog.DashboardTemplateVariablePresetTemplateVariableArgs(
                    name="var_1",
                    value="host.dc",
                ),
                datadog.DashboardTemplateVariablePresetTemplateVariableArgs(
                    name="var_2",
                    value="my_service",
                ),
            ],
        )])
    
    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 {
    		// Example Ordered Layout
    		_, err := datadog.NewDashboard(ctx, "ordered_dashboard", &datadog.DashboardArgs{
    			Title:       pulumi.String("Ordered Layout Dashboard"),
    			Description: pulumi.String("Created using the Datadog provider in Pulumi"),
    			LayoutType:  pulumi.String("ordered"),
    			Widgets: datadog.DashboardWidgetArray{
    				&datadog.DashboardWidgetArgs{
    					AlertGraphDefinition: &datadog.DashboardWidgetAlertGraphDefinitionArgs{
    						AlertId:  pulumi.String("895605"),
    						VizType:  pulumi.String("timeseries"),
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					AlertValueDefinition: &datadog.DashboardWidgetAlertValueDefinitionArgs{
    						AlertId:   pulumi.String("895605"),
    						Precision: pulumi.Int(3),
    						Unit:      pulumi.String("b"),
    						TextAlign: pulumi.String("center"),
    						Title:     pulumi.String("Widget Title"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					AlertValueDefinition: &datadog.DashboardWidgetAlertValueDefinitionArgs{
    						AlertId:   pulumi.String("895605"),
    						Precision: pulumi.Int(3),
    						Unit:      pulumi.String("b"),
    						TextAlign: pulumi.String("center"),
    						Title:     pulumi.String("Widget Title"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ChangeDefinition: &datadog.DashboardWidgetChangeDefinitionArgs{
    						Requests: datadog.DashboardWidgetChangeDefinitionRequestArray{
    							&datadog.DashboardWidgetChangeDefinitionRequestArgs{
    								Q:            pulumi.String("avg:system.load.1{env:staging} by {account}"),
    								ChangeType:   pulumi.String("absolute"),
    								CompareTo:    pulumi.String("week_before"),
    								IncreaseGood: pulumi.Bool(true),
    								OrderBy:      pulumi.String("name"),
    								OrderDir:     pulumi.String("desc"),
    								ShowPresent:  pulumi.Bool(true),
    							},
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					DistributionDefinition: &datadog.DashboardWidgetDistributionDefinitionArgs{
    						Requests: datadog.DashboardWidgetDistributionDefinitionRequestArray{
    							&datadog.DashboardWidgetDistributionDefinitionRequestArgs{
    								Q: pulumi.String("avg:system.load.1{env:staging} by {account}"),
    								Style: &datadog.DashboardWidgetDistributionDefinitionRequestStyleArgs{
    									Palette: pulumi.String("warm"),
    								},
    							},
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					CheckStatusDefinition: &datadog.DashboardWidgetCheckStatusDefinitionArgs{
    						Check:    pulumi.String("aws.ecs.agent_connected"),
    						Grouping: pulumi.String("cluster"),
    						GroupBies: pulumi.StringArray{
    							pulumi.String("account"),
    							pulumi.String("cluster"),
    						},
    						Tags: pulumi.StringArray{
    							pulumi.String("account:demo"),
    							pulumi.String("cluster:awseb-ruthebdog-env-8-dn3m6u3gvk"),
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					HeatmapDefinition: &datadog.DashboardWidgetHeatmapDefinitionArgs{
    						Requests: datadog.DashboardWidgetHeatmapDefinitionRequestArray{
    							&datadog.DashboardWidgetHeatmapDefinitionRequestArgs{
    								Q: pulumi.String("avg:system.load.1{env:staging} by {account}"),
    								Style: &datadog.DashboardWidgetHeatmapDefinitionRequestStyleArgs{
    									Palette: pulumi.String("warm"),
    								},
    							},
    						},
    						Yaxis: &datadog.DashboardWidgetHeatmapDefinitionYaxisArgs{
    							Min:         pulumi.String("1"),
    							Max:         pulumi.String("2"),
    							IncludeZero: pulumi.Bool(true),
    							Scale:       pulumi.String("sqrt"),
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					HostmapDefinition: &datadog.DashboardWidgetHostmapDefinitionArgs{
    						Request: &datadog.DashboardWidgetHostmapDefinitionRequestArgs{
    							Fills: datadog.DashboardWidgetHostmapDefinitionRequestFillArray{
    								&datadog.DashboardWidgetHostmapDefinitionRequestFillArgs{
    									Q: pulumi.String("avg:system.load.1{*} by {host}"),
    								},
    							},
    							Sizes: datadog.DashboardWidgetHostmapDefinitionRequestSizeArray{
    								&datadog.DashboardWidgetHostmapDefinitionRequestSizeArgs{
    									Q: pulumi.String("avg:memcache.uptime{*} by {host}"),
    								},
    							},
    						},
    						NodeType: pulumi.String("container"),
    						Groups: pulumi.StringArray{
    							pulumi.String("host"),
    							pulumi.String("region"),
    						},
    						NoGroupHosts:  pulumi.Bool(true),
    						NoMetricHosts: pulumi.Bool(true),
    						Scopes: pulumi.StringArray{
    							pulumi.String("region:us-east-1"),
    							pulumi.String("aws_account:727006795293"),
    						},
    						Style: &datadog.DashboardWidgetHostmapDefinitionStyleArgs{
    							Palette:     pulumi.String("yellow_to_green"),
    							PaletteFlip: pulumi.Bool(true),
    							FillMin:     pulumi.String("10"),
    							FillMax:     pulumi.String("20"),
    						},
    						Title: pulumi.String("Widget Title"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					NoteDefinition: &datadog.DashboardWidgetNoteDefinitionArgs{
    						Content:         pulumi.String("note text"),
    						BackgroundColor: pulumi.String("pink"),
    						FontSize:        pulumi.String("14"),
    						TextAlign:       pulumi.String("center"),
    						ShowTick:        pulumi.Bool(true),
    						TickEdge:        pulumi.String("left"),
    						TickPos:         pulumi.String("50%"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					QueryValueDefinition: &datadog.DashboardWidgetQueryValueDefinitionArgs{
    						Requests: datadog.DashboardWidgetQueryValueDefinitionRequestArray{
    							&datadog.DashboardWidgetQueryValueDefinitionRequestArgs{
    								Q:          pulumi.String("avg:system.load.1{env:staging} by {account}"),
    								Aggregator: pulumi.String("sum"),
    								ConditionalFormats: datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String("<"),
    										Value:      pulumi.Float64(2),
    										Palette:    pulumi.String("white_on_green"),
    									},
    									&datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String(">"),
    										Value:      pulumi.Float64(2.2),
    										Palette:    pulumi.String("white_on_red"),
    									},
    								},
    							},
    						},
    						Autoscale:  pulumi.Bool(true),
    						CustomUnit: pulumi.String("xx"),
    						Precision:  pulumi.Int(4),
    						TextAlign:  pulumi.String("right"),
    						Title:      pulumi.String("Widget Title"),
    						LiveSpan:   pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					QueryTableDefinition: &datadog.DashboardWidgetQueryTableDefinitionArgs{
    						Requests: datadog.DashboardWidgetQueryTableDefinitionRequestArray{
    							&datadog.DashboardWidgetQueryTableDefinitionRequestArgs{
    								Q:          pulumi.String("avg:system.load.1{env:staging} by {account}"),
    								Aggregator: pulumi.String("sum"),
    								Limit:      pulumi.Int(10),
    								ConditionalFormats: datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String("<"),
    										Value:      pulumi.Float64(2),
    										Palette:    pulumi.String("white_on_green"),
    									},
    									&datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String(">"),
    										Value:      pulumi.Float64(2.2),
    										Palette:    pulumi.String("white_on_red"),
    									},
    								},
    							},
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ScatterplotDefinition: &datadog.DashboardWidgetScatterplotDefinitionArgs{
    						Request: &datadog.DashboardWidgetScatterplotDefinitionRequestArgs{
    							Xes: datadog.DashboardWidgetScatterplotDefinitionRequestXArray{
    								&datadog.DashboardWidgetScatterplotDefinitionRequestXArgs{
    									Q:          pulumi.String("avg:system.cpu.user{*} by {service, account}"),
    									Aggregator: pulumi.String("max"),
    								},
    							},
    							Ys: datadog.DashboardWidgetScatterplotDefinitionRequestYArray{
    								&datadog.DashboardWidgetScatterplotDefinitionRequestYArgs{
    									Q:          pulumi.String("avg:system.mem.used{*} by {service, account}"),
    									Aggregator: pulumi.String("min"),
    								},
    							},
    						},
    						ColorByGroups: pulumi.StringArray{
    							pulumi.String("account"),
    							pulumi.String("apm-role-group"),
    						},
    						Xaxis: &datadog.DashboardWidgetScatterplotDefinitionXaxisArgs{
    							IncludeZero: pulumi.Bool(true),
    							Label:       pulumi.String("x"),
    							Min:         pulumi.String("1"),
    							Max:         pulumi.String("2000"),
    							Scale:       pulumi.String("pow"),
    						},
    						Yaxis: &datadog.DashboardWidgetScatterplotDefinitionYaxisArgs{
    							IncludeZero: pulumi.Bool(false),
    							Label:       pulumi.String("y"),
    							Min:         pulumi.String("5"),
    							Max:         pulumi.String("2222"),
    							Scale:       pulumi.String("log"),
    						},
    						Title:    pulumi.String("Widget Title"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ServicemapDefinition: &datadog.DashboardWidgetServicemapDefinitionArgs{
    						Service: pulumi.String("master-db"),
    						Filters: pulumi.StringArray{
    							pulumi.String("env:prod"),
    							pulumi.String("datacenter:dc1"),
    						},
    						Title:      pulumi.String("env: prod, datacenter:dc1, service: master-db"),
    						TitleSize:  pulumi.String("16"),
    						TitleAlign: pulumi.String("left"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								Q:           pulumi.String("avg:system.cpu.user{app:general} by {env}"),
    								DisplayType: pulumi.String("line"),
    								Style: &datadog.DashboardWidgetTimeseriesDefinitionRequestStyleArgs{
    									Palette:   pulumi.String("warm"),
    									LineType:  pulumi.String("dashed"),
    									LineWidth: pulumi.String("thin"),
    								},
    								Metadatas: datadog.DashboardWidgetTimeseriesDefinitionRequestMetadataArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs{
    										Expression: pulumi.String("avg:system.cpu.user{app:general} by {env}"),
    										AliasName:  pulumi.String("Alpha"),
    									},
    								},
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								LogQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryArgs{
    									Index: pulumi.String("mcnulty"),
    									ComputeQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryComputeQueryArgs{
    										Aggregation: pulumi.String("avg"),
    										Facet:       pulumi.String("@duration"),
    										Interval:    pulumi.Int(5000),
    									},
    									SearchQuery: pulumi.String("status:info"),
    									GroupBies: datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupByArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupByArgs{
    											Facet: pulumi.String("host"),
    											Limit: pulumi.Int(10),
    											SortQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupBySortQueryArgs{
    												Aggregation: pulumi.String("avg"),
    												Order:       pulumi.String("desc"),
    												Facet:       pulumi.String("@duration"),
    											},
    										},
    									},
    								},
    								DisplayType: pulumi.String("area"),
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								ApmQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryArgs{
    									Index: pulumi.String("apm-search"),
    									ComputeQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryComputeQueryArgs{
    										Aggregation: pulumi.String("avg"),
    										Facet:       pulumi.String("@duration"),
    										Interval:    pulumi.Int(5000),
    									},
    									SearchQuery: pulumi.String("type:web"),
    									GroupBies: datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupByArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupByArgs{
    											Facet: pulumi.String("resource_name"),
    											Limit: pulumi.Int(50),
    											SortQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupBySortQueryArgs{
    												Aggregation: pulumi.String("avg"),
    												Order:       pulumi.String("desc"),
    												Facet:       pulumi.String("@string_query.interval"),
    											},
    										},
    									},
    								},
    								DisplayType: pulumi.String("bars"),
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								ProcessQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs{
    									Metric:   pulumi.String("process.stat.cpu.total_pct"),
    									SearchBy: pulumi.String("error"),
    									FilterBies: pulumi.StringArray{
    										pulumi.String("active"),
    									},
    									Limit: pulumi.Int(50),
    								},
    								DisplayType: pulumi.String("area"),
    							},
    						},
    						Markers: datadog.DashboardWidgetTimeseriesDefinitionMarkerArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionMarkerArgs{
    								DisplayType: pulumi.String("error dashed"),
    								Label:       pulumi.String(" z=6 "),
    								Value:       pulumi.String("y = 4"),
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionMarkerArgs{
    								DisplayType: pulumi.String("ok solid"),
    								Value:       pulumi.String("10 < y < 999"),
    								Label:       pulumi.String(" x=8 "),
    							},
    						},
    						Title:      pulumi.String("Widget Title"),
    						ShowLegend: pulumi.Bool(true),
    						LegendSize: pulumi.String("2"),
    						LiveSpan:   pulumi.String("1h"),
    						Events: datadog.DashboardWidgetTimeseriesDefinitionEventArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionEventArgs{
    								Q: pulumi.String("sources:test tags:1"),
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionEventArgs{
    								Q: pulumi.String("sources:test tags:2"),
    							},
    						},
    						Yaxis: &datadog.DashboardWidgetTimeseriesDefinitionYaxisArgs{
    							Scale:       pulumi.String("log"),
    							IncludeZero: pulumi.Bool(false),
    							Max:         pulumi.String("100"),
    						},
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ToplistDefinition: &datadog.DashboardWidgetToplistDefinitionArgs{
    						Requests: datadog.DashboardWidgetToplistDefinitionRequestArray{
    							&datadog.DashboardWidgetToplistDefinitionRequestArgs{
    								Q: pulumi.String("avg:system.cpu.user{app:general} by {env}"),
    								ConditionalFormats: datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String("<"),
    										Value:      pulumi.Float64(2),
    										Palette:    pulumi.String("white_on_green"),
    									},
    									&datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String(">"),
    										Value:      pulumi.Float64(2.2),
    										Palette:    pulumi.String("white_on_red"),
    									},
    								},
    							},
    						},
    						Title: pulumi.String("Widget Title"),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					GroupDefinition: &datadog.DashboardWidgetGroupDefinitionArgs{
    						LayoutType: pulumi.String("ordered"),
    						Title:      pulumi.String("Group Widget"),
    						Widgets: datadog.DashboardWidgetGroupDefinitionWidgetArray{
    							&datadog.DashboardWidgetGroupDefinitionWidgetArgs{
    								NoteDefinition: &datadog.DashboardWidgetGroupDefinitionWidgetNoteDefinitionArgs{
    									Content:         pulumi.String("cluster note widget"),
    									BackgroundColor: pulumi.String("pink"),
    									FontSize:        pulumi.String("14"),
    									TextAlign:       pulumi.String("center"),
    									ShowTick:        pulumi.Bool(true),
    									TickEdge:        pulumi.String("left"),
    									TickPos:         pulumi.String("50%"),
    								},
    							},
    							&datadog.DashboardWidgetGroupDefinitionWidgetArgs{
    								AlertGraphDefinition: &datadog.DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs{
    									AlertId:  pulumi.String("123"),
    									VizType:  pulumi.String("toplist"),
    									Title:    pulumi.String("Alert Graph"),
    									LiveSpan: pulumi.String("1h"),
    								},
    							},
    						},
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ServiceLevelObjectiveDefinition: &datadog.DashboardWidgetServiceLevelObjectiveDefinitionArgs{
    						Title:           pulumi.String("Widget Title"),
    						ViewType:        pulumi.String("detail"),
    						SloId:           pulumi.String("56789"),
    						ShowErrorBudget: pulumi.Bool(true),
    						ViewMode:        pulumi.String("overall"),
    						TimeWindows: pulumi.StringArray{
    							pulumi.String("7d"),
    							pulumi.String("previous_week"),
    						},
    					},
    				},
    			},
    			TemplateVariables: datadog.DashboardTemplateVariableArray{
    				&datadog.DashboardTemplateVariableArgs{
    					Name:    pulumi.String("var_1"),
    					Prefix:  pulumi.String("host"),
    					Default: pulumi.String("aws"),
    				},
    				&datadog.DashboardTemplateVariableArgs{
    					Name:    pulumi.String("var_2"),
    					Prefix:  pulumi.String("service_name"),
    					Default: pulumi.String("autoscaling"),
    				},
    			},
    			TemplateVariablePresets: datadog.DashboardTemplateVariablePresetArray{
    				&datadog.DashboardTemplateVariablePresetArgs{
    					Name: pulumi.String("preset_1"),
    					TemplateVariables: datadog.DashboardTemplateVariablePresetTemplateVariableArray{
    						&datadog.DashboardTemplateVariablePresetTemplateVariableArgs{
    							Name:  pulumi.String("var_1"),
    							Value: pulumi.String("host.dc"),
    						},
    						&datadog.DashboardTemplateVariablePresetTemplateVariableArgs{
    							Name:  pulumi.String("var_2"),
    							Value: pulumi.String("my_service"),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Free Layout
    		_, err = datadog.NewDashboard(ctx, "free_dashboard", &datadog.DashboardArgs{
    			Title:       pulumi.String("Free Layout Dashboard"),
    			Description: pulumi.String("Created using the Datadog provider in Pulumi"),
    			LayoutType:  pulumi.String("free"),
    			Widgets: datadog.DashboardWidgetArray{
    				&datadog.DashboardWidgetArgs{
    					EventStreamDefinition: &datadog.DashboardWidgetEventStreamDefinitionArgs{
    						Query:      pulumi.String("*"),
    						EventSize:  pulumi.String("l"),
    						Title:      pulumi.String("Widget Title"),
    						TitleSize:  pulumi.String("16"),
    						TitleAlign: pulumi.String("left"),
    						LiveSpan:   pulumi.String("1h"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(43),
    						Width:  pulumi.Int(32),
    						X:      pulumi.Int(0),
    						Y:      pulumi.Int(0),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					EventTimelineDefinition: &datadog.DashboardWidgetEventTimelineDefinitionArgs{
    						Query:      pulumi.String("*"),
    						Title:      pulumi.String("Widget Title"),
    						TitleSize:  pulumi.String("16"),
    						TitleAlign: pulumi.String("left"),
    						LiveSpan:   pulumi.String("1h"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(9),
    						Width:  pulumi.Int(66),
    						X:      pulumi.Int(33),
    						Y:      pulumi.Int(60),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					FreeTextDefinition: &datadog.DashboardWidgetFreeTextDefinitionArgs{
    						Text:      pulumi.String("free text content"),
    						Color:     pulumi.String("#d00"),
    						FontSize:  pulumi.String("36"),
    						TextAlign: pulumi.String("left"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(20),
    						Width:  pulumi.Int(34),
    						X:      pulumi.Int(33),
    						Y:      pulumi.Int(0),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					IframeDefinition: &datadog.DashboardWidgetIframeDefinitionArgs{
    						Url: pulumi.String("http://google.com"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(46),
    						Width:  pulumi.Int(39),
    						X:      pulumi.Int(101),
    						Y:      pulumi.Int(0),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ImageDefinition: &datadog.DashboardWidgetImageDefinitionArgs{
    						Url:    pulumi.String("https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350"),
    						Sizing: pulumi.String("fit"),
    						Margin: pulumi.String("small"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(20),
    						Width:  pulumi.Int(30),
    						X:      pulumi.Int(69),
    						Y:      pulumi.Int(0),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					LogStreamDefinition: &datadog.DashboardWidgetLogStreamDefinitionArgs{
    						Indexes: pulumi.StringArray{
    							pulumi.String("main"),
    						},
    						Query: pulumi.String("error"),
    						Columns: pulumi.StringArray{
    							pulumi.String("core_host"),
    							pulumi.String("core_service"),
    							pulumi.String("tag_source"),
    						},
    						ShowDateColumn:    pulumi.Bool(true),
    						ShowMessageColumn: pulumi.Bool(true),
    						MessageDisplay:    pulumi.String("expanded-md"),
    						Sort: &datadog.DashboardWidgetLogStreamDefinitionSortArgs{
    							Column: pulumi.String("time"),
    							Order:  pulumi.String("desc"),
    						},
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(36),
    						Width:  pulumi.Int(32),
    						X:      pulumi.Int(0),
    						Y:      pulumi.Int(45),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					ManageStatusDefinition: &datadog.DashboardWidgetManageStatusDefinitionArgs{
    						ColorPreference:   pulumi.String("text"),
    						DisplayFormat:     pulumi.String("countsAndList"),
    						HideZeroCounts:    pulumi.Bool(true),
    						Query:             pulumi.String("type:metric"),
    						ShowLastTriggered: pulumi.Bool(false),
    						Sort:              pulumi.String("status,asc"),
    						SummaryType:       pulumi.String("monitors"),
    						Title:             pulumi.String("Widget Title"),
    						TitleSize:         pulumi.String("16"),
    						TitleAlign:        pulumi.String("left"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(40),
    						Width:  pulumi.Int(30),
    						X:      pulumi.Int(101),
    						Y:      pulumi.Int(48),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TraceServiceDefinition: &datadog.DashboardWidgetTraceServiceDefinitionArgs{
    						DisplayFormat:    pulumi.String("three_column"),
    						Env:              pulumi.String("datadog.com"),
    						Service:          pulumi.String("alerting-cassandra"),
    						ShowBreakdown:    pulumi.Bool(true),
    						ShowDistribution: pulumi.Bool(true),
    						ShowErrors:       pulumi.Bool(true),
    						ShowHits:         pulumi.Bool(true),
    						ShowLatency:      pulumi.Bool(false),
    						ShowResourceList: pulumi.Bool(false),
    						SizeFormat:       pulumi.String("large"),
    						SpanName:         pulumi.String("cassandra.query"),
    						Title:            pulumi.String("alerting-cassandra #env:datadog.com"),
    						TitleAlign:       pulumi.String("center"),
    						TitleSize:        pulumi.String("13"),
    						LiveSpan:         pulumi.String("1h"),
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(38),
    						Width:  pulumi.Int(66),
    						X:      pulumi.Int(33),
    						Y:      pulumi.Int(21),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								Formulas: datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("my_query_1 + my_query_2"),
    										Alias:             pulumi.String("my ff query"),
    									},
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("my_query_1 * my_query_2"),
    										Limit: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(5),
    											Order: pulumi.String("desc"),
    										},
    										Alias: pulumi.String("my second ff query"),
    									},
    								},
    								Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    											DataSource: pulumi.String("metrics"),
    											Query:      pulumi.String("avg:system.cpu.user{app:general} by {env}"),
    											Name:       pulumi.String("my_query_1"),
    											Aggregator: pulumi.String("sum"),
    										},
    									},
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    											Query:      pulumi.String("avg:system.cpu.user{app:general} by {env}"),
    											Name:       pulumi.String("my_query_2"),
    											Aggregator: pulumi.String("sum"),
    										},
    									},
    								},
    							},
    						},
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(16),
    						Width:  pulumi.Int(25),
    						X:      pulumi.Int(58),
    						Y:      pulumi.Int(83),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										EventQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs{
    											Name:       pulumi.String("my-query"),
    											DataSource: pulumi.String("logs"),
    											Indexes: pulumi.StringArray{
    												pulumi.String("days-3"),
    											},
    											Computes: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("count"),
    												},
    											},
    											GroupBies: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("host"),
    													Sort: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Metric:      pulumi.String("@lambda.max_memory_used"),
    														Aggregation: pulumi.String("avg"),
    													},
    													Limit: pulumi.Int(10),
    												},
    											},
    										},
    									},
    								},
    							},
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								DisplayType: pulumi.String("overlay"),
    								Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    											Name:       pulumi.String("MyOverlay"),
    											DataSource: pulumi.String("metrics"),
    											Query:      pulumi.String("avg:system.cpu.user{host:COMP-QJWVM2FYT4}"),
    										},
    									},
    								},
    							},
    						},
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(16),
    						Width:  pulumi.Int(28),
    						X:      pulumi.Int(29),
    						Y:      pulumi.Int(83),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										ProcessQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs{
    											DataSource: pulumi.String("process"),
    											TextFilter: pulumi.String("abc"),
    											Metric:     pulumi.String("process.stat.cpu.total_pct"),
    											Limit:      pulumi.Int(10),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("some_filter"),
    											},
    											Name:            pulumi.String("my_process_query"),
    											Sort:            pulumi.String("asc"),
    											IsNormalizedCpu: pulumi.Bool(true),
    											Aggregator:      pulumi.String("sum"),
    										},
    									},
    								},
    							},
    						},
    					},
    					WidgetLayout: &datadog.DashboardWidgetWidgetLayoutArgs{
    						Height: pulumi.Int(16),
    						Width:  pulumi.Int(28),
    						X:      pulumi.Int(0),
    						Y:      pulumi.Int(83),
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    								Formulas: datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("query1"),
    										Alias:             pulumi.String("my cloud cost query"),
    									},
    								},
    								Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    										CloudCostQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource: pulumi.String("cloud_cost"),
    											Query:      pulumi.String("sum:aws.cost.amortized{*}"),
    											Name:       pulumi.String("query1"),
    											Aggregator: pulumi.String("sum"),
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    				&datadog.DashboardWidgetArgs{
    					PowerpackDefinition: &datadog.DashboardWidgetPowerpackDefinitionArgs{
    						PowerpackId:     pulumi.String("00000000-0000-0000-0000-000000000000"),
    						BackgroundColor: pulumi.String("blue"),
    						BannerImg:       pulumi.String("https://example.org/example.png"),
    						ShowTitle:       pulumi.Bool(true),
    						Title:           pulumi.String("Powerpack Widget"),
    						TemplateVariables: &datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs{
    							ControlledExternallies: datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArray{
    								&datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs{
    									Name: pulumi.String("var_2"),
    									Values: pulumi.StringArray{
    										pulumi.String("autoscaling"),
    									},
    									Prefix: pulumi.String("service_name"),
    								},
    							},
    							ControlledByPowerpacks: datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArray{
    								&datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs{
    									Name:   pulumi.String("var_3"),
    									Prefix: pulumi.String("timeframe"),
    									Values: pulumi.StringArray{
    										pulumi.String("default"),
    										pulumi.String("values"),
    										pulumi.String("here"),
    									},
    								},
    							},
    						},
    					},
    				},
    			},
    			TemplateVariables: datadog.DashboardTemplateVariableArray{
    				&datadog.DashboardTemplateVariableArgs{
    					Name:    pulumi.String("var_1"),
    					Prefix:  pulumi.String("host"),
    					Default: pulumi.String("aws"),
    				},
    				&datadog.DashboardTemplateVariableArgs{
    					Name:    pulumi.String("var_2"),
    					Prefix:  pulumi.String("service_name"),
    					Default: pulumi.String("autoscaling"),
    				},
    			},
    			TemplateVariablePresets: datadog.DashboardTemplateVariablePresetArray{
    				&datadog.DashboardTemplateVariablePresetArgs{
    					Name: pulumi.String("preset_1"),
    					TemplateVariables: datadog.DashboardTemplateVariablePresetTemplateVariableArray{
    						&datadog.DashboardTemplateVariablePresetTemplateVariableArgs{
    							Name:  pulumi.String("var_1"),
    							Value: pulumi.String("host.dc"),
    						},
    						&datadog.DashboardTemplateVariablePresetTemplateVariableArgs{
    							Name:  pulumi.String("var_2"),
    							Value: pulumi.String("my_service"),
    						},
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Datadog = Pulumi.Datadog;
    
    return await Deployment.RunAsync(() => 
    {
        // Example Ordered Layout
        var orderedDashboard = new Datadog.Dashboard("ordered_dashboard", new()
        {
            Title = "Ordered Layout Dashboard",
            Description = "Created using the Datadog provider in Pulumi",
            LayoutType = "ordered",
            Widgets = new[]
            {
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                    {
                        AlertId = "895605",
                        VizType = "timeseries",
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                    {
                        AlertId = "895605",
                        Precision = 3,
                        Unit = "b",
                        TextAlign = "center",
                        Title = "Widget Title",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                    {
                        AlertId = "895605",
                        Precision = 3,
                        Unit = "b",
                        TextAlign = "center",
                        Title = "Widget Title",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                            {
                                Q = "avg:system.load.1{env:staging} by {account}",
                                ChangeType = "absolute",
                                CompareTo = "week_before",
                                IncreaseGood = true,
                                OrderBy = "name",
                                OrderDir = "desc",
                                ShowPresent = true,
                            },
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    DistributionDefinition = new Datadog.Inputs.DashboardWidgetDistributionDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestArgs
                            {
                                Q = "avg:system.load.1{env:staging} by {account}",
                                Style = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestStyleArgs
                                {
                                    Palette = "warm",
                                },
                            },
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetCheckStatusDefinitionArgs
                    {
                        Check = "aws.ecs.agent_connected",
                        Grouping = "cluster",
                        GroupBies = new[]
                        {
                            "account",
                            "cluster",
                        },
                        Tags = new[]
                        {
                            "account:demo",
                            "cluster:awseb-ruthebdog-env-8-dn3m6u3gvk",
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    HeatmapDefinition = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestArgs
                            {
                                Q = "avg:system.load.1{env:staging} by {account}",
                                Style = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestStyleArgs
                                {
                                    Palette = "warm",
                                },
                            },
                        },
                        Yaxis = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionYaxisArgs
                        {
                            Min = "1",
                            Max = "2",
                            IncludeZero = true,
                            Scale = "sqrt",
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    HostmapDefinition = new Datadog.Inputs.DashboardWidgetHostmapDefinitionArgs
                    {
                        Request = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestArgs
                        {
                            Fills = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestFillArgs
                                {
                                    Q = "avg:system.load.1{*} by {host}",
                                },
                            },
                            Sizes = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestSizeArgs
                                {
                                    Q = "avg:memcache.uptime{*} by {host}",
                                },
                            },
                        },
                        NodeType = "container",
                        Groups = new[]
                        {
                            "host",
                            "region",
                        },
                        NoGroupHosts = true,
                        NoMetricHosts = true,
                        Scopes = new[]
                        {
                            "region:us-east-1",
                            "aws_account:727006795293",
                        },
                        Style = new Datadog.Inputs.DashboardWidgetHostmapDefinitionStyleArgs
                        {
                            Palette = "yellow_to_green",
                            PaletteFlip = true,
                            FillMin = "10",
                            FillMax = "20",
                        },
                        Title = "Widget Title",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    NoteDefinition = new Datadog.Inputs.DashboardWidgetNoteDefinitionArgs
                    {
                        Content = "note text",
                        BackgroundColor = "pink",
                        FontSize = "14",
                        TextAlign = "center",
                        ShowTick = true,
                        TickEdge = "left",
                        TickPos = "50%",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    QueryValueDefinition = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestArgs
                            {
                                Q = "avg:system.load.1{env:staging} by {account}",
                                Aggregator = "sum",
                                ConditionalFormats = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = "<",
                                        Value = 2,
                                        Palette = "white_on_green",
                                    },
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = ">",
                                        Value = 2.2,
                                        Palette = "white_on_red",
                                    },
                                },
                            },
                        },
                        Autoscale = true,
                        CustomUnit = "xx",
                        Precision = 4,
                        TextAlign = "right",
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    QueryTableDefinition = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestArgs
                            {
                                Q = "avg:system.load.1{env:staging} by {account}",
                                Aggregator = "sum",
                                Limit = 10,
                                ConditionalFormats = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = "<",
                                        Value = 2,
                                        Palette = "white_on_green",
                                    },
                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = ">",
                                        Value = 2.2,
                                        Palette = "white_on_red",
                                    },
                                },
                            },
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionArgs
                    {
                        Request = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestArgs
                        {
                            Xes = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXArgs
                                {
                                    Q = "avg:system.cpu.user{*} by {service, account}",
                                    Aggregator = "max",
                                },
                            },
                            Ys = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYArgs
                                {
                                    Q = "avg:system.mem.used{*} by {service, account}",
                                    Aggregator = "min",
                                },
                            },
                        },
                        ColorByGroups = new[]
                        {
                            "account",
                            "apm-role-group",
                        },
                        Xaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionXaxisArgs
                        {
                            IncludeZero = true,
                            Label = "x",
                            Min = "1",
                            Max = "2000",
                            Scale = "pow",
                        },
                        Yaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionYaxisArgs
                        {
                            IncludeZero = false,
                            Label = "y",
                            Min = "5",
                            Max = "2222",
                            Scale = "log",
                        },
                        Title = "Widget Title",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ServicemapDefinition = new Datadog.Inputs.DashboardWidgetServicemapDefinitionArgs
                    {
                        Service = "master-db",
                        Filters = new[]
                        {
                            "env:prod",
                            "datacenter:dc1",
                        },
                        Title = "env: prod, datacenter:dc1, service: master-db",
                        TitleSize = "16",
                        TitleAlign = "left",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                Q = "avg:system.cpu.user{app:general} by {env}",
                                DisplayType = "line",
                                Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestStyleArgs
                                {
                                    Palette = "warm",
                                    LineType = "dashed",
                                    LineWidth = "thin",
                                },
                                Metadatas = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs
                                    {
                                        Expression = "avg:system.cpu.user{app:general} by {env}",
                                        AliasName = "Alpha",
                                    },
                                },
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                LogQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestLogQueryArgs
                                {
                                    Index = "mcnulty",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "avg",
                                        Facet = "@duration",
                                        Interval = 5000,
                                    },
                                    SearchQuery = "status:info",
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupByArgs
                                        {
                                            Facet = "host",
                                            Limit = 10,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "avg",
                                                Order = "desc",
                                                Facet = "@duration",
                                            },
                                        },
                                    },
                                },
                                DisplayType = "area",
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                ApmQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestApmQueryArgs
                                {
                                    Index = "apm-search",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "avg",
                                        Facet = "@duration",
                                        Interval = 5000,
                                    },
                                    SearchQuery = "type:web",
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupByArgs
                                        {
                                            Facet = "resource_name",
                                            Limit = 50,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "avg",
                                                Order = "desc",
                                                Facet = "@string_query.interval",
                                            },
                                        },
                                    },
                                },
                                DisplayType = "bars",
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs
                                {
                                    Metric = "process.stat.cpu.total_pct",
                                    SearchBy = "error",
                                    FilterBies = new[]
                                    {
                                        "active",
                                    },
                                    Limit = 50,
                                },
                                DisplayType = "area",
                            },
                        },
                        Markers = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                            {
                                DisplayType = "error dashed",
                                Label = " z=6 ",
                                Value = "y = 4",
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                            {
                                DisplayType = "ok solid",
                                Value = "10 < y < 999",
                                Label = " x=8 ",
                            },
                        },
                        Title = "Widget Title",
                        ShowLegend = true,
                        LegendSize = "2",
                        LiveSpan = "1h",
                        Events = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                            {
                                Q = "sources:test tags:1",
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                            {
                                Q = "sources:test tags:2",
                            },
                        },
                        Yaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs
                        {
                            Scale = "log",
                            IncludeZero = false,
                            Max = "100",
                        },
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ToplistDefinition = new Datadog.Inputs.DashboardWidgetToplistDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestArgs
                            {
                                Q = "avg:system.cpu.user{app:general} by {env}",
                                ConditionalFormats = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = "<",
                                        Value = 2,
                                        Palette = "white_on_green",
                                    },
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = ">",
                                        Value = 2.2,
                                        Palette = "white_on_red",
                                    },
                                },
                            },
                        },
                        Title = "Widget Title",
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    GroupDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionArgs
                    {
                        LayoutType = "ordered",
                        Title = "Group Widget",
                        Widgets = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetArgs
                            {
                                NoteDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetNoteDefinitionArgs
                                {
                                    Content = "cluster note widget",
                                    BackgroundColor = "pink",
                                    FontSize = "14",
                                    TextAlign = "center",
                                    ShowTick = true,
                                    TickEdge = "left",
                                    TickPos = "50%",
                                },
                            },
                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetArgs
                            {
                                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs
                                {
                                    AlertId = "123",
                                    VizType = "toplist",
                                    Title = "Alert Graph",
                                    LiveSpan = "1h",
                                },
                            },
                        },
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardWidgetServiceLevelObjectiveDefinitionArgs
                    {
                        Title = "Widget Title",
                        ViewType = "detail",
                        SloId = "56789",
                        ShowErrorBudget = true,
                        ViewMode = "overall",
                        TimeWindows = new[]
                        {
                            "7d",
                            "previous_week",
                        },
                    },
                },
            },
            TemplateVariables = new[]
            {
                new Datadog.Inputs.DashboardTemplateVariableArgs
                {
                    Name = "var_1",
                    Prefix = "host",
                    Default = "aws",
                },
                new Datadog.Inputs.DashboardTemplateVariableArgs
                {
                    Name = "var_2",
                    Prefix = "service_name",
                    Default = "autoscaling",
                },
            },
            TemplateVariablePresets = new[]
            {
                new Datadog.Inputs.DashboardTemplateVariablePresetArgs
                {
                    Name = "preset_1",
                    TemplateVariables = new[]
                    {
                        new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                        {
                            Name = "var_1",
                            Value = "host.dc",
                        },
                        new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                        {
                            Name = "var_2",
                            Value = "my_service",
                        },
                    },
                },
            },
        });
    
        // Example Free Layout
        var freeDashboard = new Datadog.Dashboard("free_dashboard", new()
        {
            Title = "Free Layout Dashboard",
            Description = "Created using the Datadog provider in Pulumi",
            LayoutType = "free",
            Widgets = new[]
            {
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    EventStreamDefinition = new Datadog.Inputs.DashboardWidgetEventStreamDefinitionArgs
                    {
                        Query = "*",
                        EventSize = "l",
                        Title = "Widget Title",
                        TitleSize = "16",
                        TitleAlign = "left",
                        LiveSpan = "1h",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 43,
                        Width = 32,
                        X = 0,
                        Y = 0,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetEventTimelineDefinitionArgs
                    {
                        Query = "*",
                        Title = "Widget Title",
                        TitleSize = "16",
                        TitleAlign = "left",
                        LiveSpan = "1h",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 9,
                        Width = 66,
                        X = 33,
                        Y = 60,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    FreeTextDefinition = new Datadog.Inputs.DashboardWidgetFreeTextDefinitionArgs
                    {
                        Text = "free text content",
                        Color = "#d00",
                        FontSize = "36",
                        TextAlign = "left",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 20,
                        Width = 34,
                        X = 33,
                        Y = 0,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    IframeDefinition = new Datadog.Inputs.DashboardWidgetIframeDefinitionArgs
                    {
                        Url = "http://google.com",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 46,
                        Width = 39,
                        X = 101,
                        Y = 0,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ImageDefinition = new Datadog.Inputs.DashboardWidgetImageDefinitionArgs
                    {
                        Url = "https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350",
                        Sizing = "fit",
                        Margin = "small",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 20,
                        Width = 30,
                        X = 69,
                        Y = 0,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    LogStreamDefinition = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionArgs
                    {
                        Indexes = new[]
                        {
                            "main",
                        },
                        Query = "error",
                        Columns = new[]
                        {
                            "core_host",
                            "core_service",
                            "tag_source",
                        },
                        ShowDateColumn = true,
                        ShowMessageColumn = true,
                        MessageDisplay = "expanded-md",
                        Sort = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionSortArgs
                        {
                            Column = "time",
                            Order = "desc",
                        },
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 36,
                        Width = 32,
                        X = 0,
                        Y = 45,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    ManageStatusDefinition = new Datadog.Inputs.DashboardWidgetManageStatusDefinitionArgs
                    {
                        ColorPreference = "text",
                        DisplayFormat = "countsAndList",
                        HideZeroCounts = true,
                        Query = "type:metric",
                        ShowLastTriggered = false,
                        Sort = "status,asc",
                        SummaryType = "monitors",
                        Title = "Widget Title",
                        TitleSize = "16",
                        TitleAlign = "left",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 40,
                        Width = 30,
                        X = 101,
                        Y = 48,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TraceServiceDefinition = new Datadog.Inputs.DashboardWidgetTraceServiceDefinitionArgs
                    {
                        DisplayFormat = "three_column",
                        Env = "datadog.com",
                        Service = "alerting-cassandra",
                        ShowBreakdown = true,
                        ShowDistribution = true,
                        ShowErrors = true,
                        ShowHits = true,
                        ShowLatency = false,
                        ShowResourceList = false,
                        SizeFormat = "large",
                        SpanName = "cassandra.query",
                        Title = "alerting-cassandra #env:datadog.com",
                        TitleAlign = "center",
                        TitleSize = "13",
                        LiveSpan = "1h",
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 38,
                        Width = 66,
                        X = 33,
                        Y = 21,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "my_query_1 + my_query_2",
                                        Alias = "my ff query",
                                    },
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "my_query_1 * my_query_2",
                                        Limit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                        {
                                            Count = 5,
                                            Order = "desc",
                                        },
                                        Alias = "my second ff query",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                        {
                                            DataSource = "metrics",
                                            Query = "avg:system.cpu.user{app:general} by {env}",
                                            Name = "my_query_1",
                                            Aggregator = "sum",
                                        },
                                    },
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                        {
                                            Query = "avg:system.cpu.user{app:general} by {env}",
                                            Name = "my_query_2",
                                            Aggregator = "sum",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 16,
                        Width = 25,
                        X = 58,
                        Y = 83,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        EventQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                        {
                                            Name = "my-query",
                                            DataSource = "logs",
                                            Indexes = new[]
                                            {
                                                "days-3",
                                            },
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "count",
                                                },
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "host",
                                                    Sort = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                    {
                                                        Metric = "@lambda.max_memory_used",
                                                        Aggregation = "avg",
                                                    },
                                                    Limit = 10,
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                DisplayType = "overlay",
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                        {
                                            Name = "MyOverlay",
                                            DataSource = "metrics",
                                            Query = "avg:system.cpu.user{host:COMP-QJWVM2FYT4}",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 16,
                        Width = 28,
                        X = 29,
                        Y = 83,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                        {
                                            DataSource = "process",
                                            TextFilter = "abc",
                                            Metric = "process.stat.cpu.total_pct",
                                            Limit = 10,
                                            TagFilters = new[]
                                            {
                                                "some_filter",
                                            },
                                            Name = "my_process_query",
                                            Sort = "asc",
                                            IsNormalizedCpu = true,
                                            Aggregator = "sum",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                    {
                        Height = 16,
                        Width = 28,
                        X = 0,
                        Y = 83,
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "query1",
                                        Alias = "my cloud cost query",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        CloudCostQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                        {
                                            DataSource = "cloud_cost",
                                            Query = "sum:aws.cost.amortized{*}",
                                            Name = "query1",
                                            Aggregator = "sum",
                                        },
                                    },
                                },
                            },
                        },
                    },
                },
                new Datadog.Inputs.DashboardWidgetArgs
                {
                    PowerpackDefinition = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionArgs
                    {
                        PowerpackId = "00000000-0000-0000-0000-000000000000",
                        BackgroundColor = "blue",
                        BannerImg = "https://example.org/example.png",
                        ShowTitle = true,
                        Title = "Powerpack Widget",
                        TemplateVariables = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs
                        {
                            ControlledExternallies = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs
                                {
                                    Name = "var_2",
                                    Values = new[]
                                    {
                                        "autoscaling",
                                    },
                                    Prefix = "service_name",
                                },
                            },
                            ControlledByPowerpacks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs
                                {
                                    Name = "var_3",
                                    Prefix = "timeframe",
                                    Values = new[]
                                    {
                                        "default",
                                        "values",
                                        "here",
                                    },
                                },
                            },
                        },
                    },
                },
            },
            TemplateVariables = new[]
            {
                new Datadog.Inputs.DashboardTemplateVariableArgs
                {
                    Name = "var_1",
                    Prefix = "host",
                    Default = "aws",
                },
                new Datadog.Inputs.DashboardTemplateVariableArgs
                {
                    Name = "var_2",
                    Prefix = "service_name",
                    Default = "autoscaling",
                },
            },
            TemplateVariablePresets = new[]
            {
                new Datadog.Inputs.DashboardTemplateVariablePresetArgs
                {
                    Name = "preset_1",
                    TemplateVariables = new[]
                    {
                        new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                        {
                            Name = "var_1",
                            Value = "host.dc",
                        },
                        new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                        {
                            Name = "var_2",
                            Value = "my_service",
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.datadog.Dashboard;
    import com.pulumi.datadog.DashboardArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetAlertGraphDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetAlertValueDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetChangeDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetDistributionDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetCheckStatusDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetHeatmapDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetHeatmapDefinitionYaxisArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetHostmapDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetHostmapDefinitionRequestArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetHostmapDefinitionStyleArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetNoteDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetQueryValueDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetQueryTableDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetScatterplotDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetScatterplotDefinitionRequestArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetScatterplotDefinitionXaxisArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetScatterplotDefinitionYaxisArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetServicemapDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetTimeseriesDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetToplistDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetGroupDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetServiceLevelObjectiveDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardTemplateVariableArgs;
    import com.pulumi.datadog.inputs.DashboardTemplateVariablePresetArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetEventStreamDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetWidgetLayoutArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetEventTimelineDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetFreeTextDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetIframeDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetImageDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetLogStreamDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetLogStreamDefinitionSortArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetManageStatusDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetTraceServiceDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetPowerpackDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs;
    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) {
            // Example Ordered Layout
            var orderedDashboard = new Dashboard("orderedDashboard", DashboardArgs.builder()        
                .title("Ordered Layout Dashboard")
                .description("Created using the Datadog provider in Pulumi")
                .layoutType("ordered")
                .widgets(            
                    DashboardWidgetArgs.builder()
                        .alertGraphDefinition(DashboardWidgetAlertGraphDefinitionArgs.builder()
                            .alertId("895605")
                            .vizType("timeseries")
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .alertValueDefinition(DashboardWidgetAlertValueDefinitionArgs.builder()
                            .alertId("895605")
                            .precision(3)
                            .unit("b")
                            .textAlign("center")
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .alertValueDefinition(DashboardWidgetAlertValueDefinitionArgs.builder()
                            .alertId("895605")
                            .precision(3)
                            .unit("b")
                            .textAlign("center")
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .changeDefinition(DashboardWidgetChangeDefinitionArgs.builder()
                            .requests(DashboardWidgetChangeDefinitionRequestArgs.builder()
                                .q("avg:system.load.1{env:staging} by {account}")
                                .changeType("absolute")
                                .compareTo("week_before")
                                .increaseGood(true)
                                .orderBy("name")
                                .orderDir("desc")
                                .showPresent(true)
                                .build())
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .distributionDefinition(DashboardWidgetDistributionDefinitionArgs.builder()
                            .requests(DashboardWidgetDistributionDefinitionRequestArgs.builder()
                                .q("avg:system.load.1{env:staging} by {account}")
                                .style(DashboardWidgetDistributionDefinitionRequestStyleArgs.builder()
                                    .palette("warm")
                                    .build())
                                .build())
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .checkStatusDefinition(DashboardWidgetCheckStatusDefinitionArgs.builder()
                            .check("aws.ecs.agent_connected")
                            .grouping("cluster")
                            .groupBies(                        
                                "account",
                                "cluster")
                            .tags(                        
                                "account:demo",
                                "cluster:awseb-ruthebdog-env-8-dn3m6u3gvk")
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .heatmapDefinition(DashboardWidgetHeatmapDefinitionArgs.builder()
                            .requests(DashboardWidgetHeatmapDefinitionRequestArgs.builder()
                                .q("avg:system.load.1{env:staging} by {account}")
                                .style(DashboardWidgetHeatmapDefinitionRequestStyleArgs.builder()
                                    .palette("warm")
                                    .build())
                                .build())
                            .yaxis(DashboardWidgetHeatmapDefinitionYaxisArgs.builder()
                                .min(1)
                                .max(2)
                                .includeZero(true)
                                .scale("sqrt")
                                .build())
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .hostmapDefinition(DashboardWidgetHostmapDefinitionArgs.builder()
                            .request(DashboardWidgetHostmapDefinitionRequestArgs.builder()
                                .fills(DashboardWidgetHostmapDefinitionRequestFillArgs.builder()
                                    .q("avg:system.load.1{*} by {host}")
                                    .build())
                                .sizes(DashboardWidgetHostmapDefinitionRequestSizeArgs.builder()
                                    .q("avg:memcache.uptime{*} by {host}")
                                    .build())
                                .build())
                            .nodeType("container")
                            .groups(                        
                                "host",
                                "region")
                            .noGroupHosts(true)
                            .noMetricHosts(true)
                            .scopes(                        
                                "region:us-east-1",
                                "aws_account:727006795293")
                            .style(DashboardWidgetHostmapDefinitionStyleArgs.builder()
                                .palette("yellow_to_green")
                                .paletteFlip(true)
                                .fillMin("10")
                                .fillMax("20")
                                .build())
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .noteDefinition(DashboardWidgetNoteDefinitionArgs.builder()
                            .content("note text")
                            .backgroundColor("pink")
                            .fontSize("14")
                            .textAlign("center")
                            .showTick(true)
                            .tickEdge("left")
                            .tickPos("50%")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .queryValueDefinition(DashboardWidgetQueryValueDefinitionArgs.builder()
                            .requests(DashboardWidgetQueryValueDefinitionRequestArgs.builder()
                                .q("avg:system.load.1{env:staging} by {account}")
                                .aggregator("sum")
                                .conditionalFormats(                            
                                    DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator("<")
                                        .value("2")
                                        .palette("white_on_green")
                                        .build(),
                                    DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator(">")
                                        .value("2.2")
                                        .palette("white_on_red")
                                        .build())
                                .build())
                            .autoscale(true)
                            .customUnit("xx")
                            .precision("4")
                            .textAlign("right")
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .queryTableDefinition(DashboardWidgetQueryTableDefinitionArgs.builder()
                            .requests(DashboardWidgetQueryTableDefinitionRequestArgs.builder()
                                .q("avg:system.load.1{env:staging} by {account}")
                                .aggregator("sum")
                                .limit("10")
                                .conditionalFormats(                            
                                    DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator("<")
                                        .value("2")
                                        .palette("white_on_green")
                                        .build(),
                                    DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator(">")
                                        .value("2.2")
                                        .palette("white_on_red")
                                        .build())
                                .build())
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .scatterplotDefinition(DashboardWidgetScatterplotDefinitionArgs.builder()
                            .request(DashboardWidgetScatterplotDefinitionRequestArgs.builder()
                                .xes(DashboardWidgetScatterplotDefinitionRequestXArgs.builder()
                                    .q("avg:system.cpu.user{*} by {service, account}")
                                    .aggregator("max")
                                    .build())
                                .ys(DashboardWidgetScatterplotDefinitionRequestYArgs.builder()
                                    .q("avg:system.mem.used{*} by {service, account}")
                                    .aggregator("min")
                                    .build())
                                .build())
                            .colorByGroups(                        
                                "account",
                                "apm-role-group")
                            .xaxis(DashboardWidgetScatterplotDefinitionXaxisArgs.builder()
                                .includeZero(true)
                                .label("x")
                                .min("1")
                                .max("2000")
                                .scale("pow")
                                .build())
                            .yaxis(DashboardWidgetScatterplotDefinitionYaxisArgs.builder()
                                .includeZero(false)
                                .label("y")
                                .min("5")
                                .max("2222")
                                .scale("log")
                                .build())
                            .title("Widget Title")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .servicemapDefinition(DashboardWidgetServicemapDefinitionArgs.builder()
                            .service("master-db")
                            .filters(                        
                                "env:prod",
                                "datacenter:dc1")
                            .title("env: prod, datacenter:dc1, service: master-db")
                            .titleSize("16")
                            .titleAlign("left")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .requests(                        
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .q("avg:system.cpu.user{app:general} by {env}")
                                    .displayType("line")
                                    .style(DashboardWidgetTimeseriesDefinitionRequestStyleArgs.builder()
                                        .palette("warm")
                                        .lineType("dashed")
                                        .lineWidth("thin")
                                        .build())
                                    .metadatas(DashboardWidgetTimeseriesDefinitionRequestMetadataArgs.builder()
                                        .expression("avg:system.cpu.user{app:general} by {env}")
                                        .aliasName("Alpha")
                                        .build())
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .logQuery(DashboardWidgetTimeseriesDefinitionRequestLogQueryArgs.builder()
                                        .index("mcnulty")
                                        .computeQuery(DashboardWidgetTimeseriesDefinitionRequestLogQueryComputeQueryArgs.builder()
                                            .aggregation("avg")
                                            .facet("@duration")
                                            .interval(5000)
                                            .build())
                                        .searchQuery("status:info")
                                        .groupBies(DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupByArgs.builder()
                                            .facet("host")
                                            .limit(10)
                                            .sortQuery(DashboardWidgetTimeseriesDefinitionRequestLogQueryGroupBySortQueryArgs.builder()
                                                .aggregation("avg")
                                                .order("desc")
                                                .facet("@duration")
                                                .build())
                                            .build())
                                        .build())
                                    .displayType("area")
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .apmQuery(DashboardWidgetTimeseriesDefinitionRequestApmQueryArgs.builder()
                                        .index("apm-search")
                                        .computeQuery(DashboardWidgetTimeseriesDefinitionRequestApmQueryComputeQueryArgs.builder()
                                            .aggregation("avg")
                                            .facet("@duration")
                                            .interval(5000)
                                            .build())
                                        .searchQuery("type:web")
                                        .groupBies(DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupByArgs.builder()
                                            .facet("resource_name")
                                            .limit(50)
                                            .sortQuery(DashboardWidgetTimeseriesDefinitionRequestApmQueryGroupBySortQueryArgs.builder()
                                                .aggregation("avg")
                                                .order("desc")
                                                .facet("@string_query.interval")
                                                .build())
                                            .build())
                                        .build())
                                    .displayType("bars")
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .processQuery(DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs.builder()
                                        .metric("process.stat.cpu.total_pct")
                                        .searchBy("error")
                                        .filterBies("active")
                                        .limit(50)
                                        .build())
                                    .displayType("area")
                                    .build())
                            .markers(                        
                                DashboardWidgetTimeseriesDefinitionMarkerArgs.builder()
                                    .displayType("error dashed")
                                    .label(" z=6 ")
                                    .value("y = 4")
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionMarkerArgs.builder()
                                    .displayType("ok solid")
                                    .value("10 < y < 999")
                                    .label(" x=8 ")
                                    .build())
                            .title("Widget Title")
                            .showLegend(true)
                            .legendSize("2")
                            .liveSpan("1h")
                            .events(                        
                                DashboardWidgetTimeseriesDefinitionEventArgs.builder()
                                    .q("sources:test tags:1")
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionEventArgs.builder()
                                    .q("sources:test tags:2")
                                    .build())
                            .yaxis(DashboardWidgetTimeseriesDefinitionYaxisArgs.builder()
                                .scale("log")
                                .includeZero(false)
                                .max(100)
                                .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .toplistDefinition(DashboardWidgetToplistDefinitionArgs.builder()
                            .requests(DashboardWidgetToplistDefinitionRequestArgs.builder()
                                .q("avg:system.cpu.user{app:general} by {env}")
                                .conditionalFormats(                            
                                    DashboardWidgetToplistDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator("<")
                                        .value("2")
                                        .palette("white_on_green")
                                        .build(),
                                    DashboardWidgetToplistDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator(">")
                                        .value("2.2")
                                        .palette("white_on_red")
                                        .build())
                                .build())
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .groupDefinition(DashboardWidgetGroupDefinitionArgs.builder()
                            .layoutType("ordered")
                            .title("Group Widget")
                            .widgets(                        
                                DashboardWidgetGroupDefinitionWidgetArgs.builder()
                                    .noteDefinition(DashboardWidgetGroupDefinitionWidgetNoteDefinitionArgs.builder()
                                        .content("cluster note widget")
                                        .backgroundColor("pink")
                                        .fontSize("14")
                                        .textAlign("center")
                                        .showTick(true)
                                        .tickEdge("left")
                                        .tickPos("50%")
                                        .build())
                                    .build(),
                                DashboardWidgetGroupDefinitionWidgetArgs.builder()
                                    .alertGraphDefinition(DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs.builder()
                                        .alertId("123")
                                        .vizType("toplist")
                                        .title("Alert Graph")
                                        .liveSpan("1h")
                                        .build())
                                    .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .serviceLevelObjectiveDefinition(DashboardWidgetServiceLevelObjectiveDefinitionArgs.builder()
                            .title("Widget Title")
                            .viewType("detail")
                            .sloId("56789")
                            .showErrorBudget(true)
                            .viewMode("overall")
                            .timeWindows(                        
                                "7d",
                                "previous_week")
                            .build())
                        .build())
                .templateVariables(            
                    DashboardTemplateVariableArgs.builder()
                        .name("var_1")
                        .prefix("host")
                        .default_("aws")
                        .build(),
                    DashboardTemplateVariableArgs.builder()
                        .name("var_2")
                        .prefix("service_name")
                        .default_("autoscaling")
                        .build())
                .templateVariablePresets(DashboardTemplateVariablePresetArgs.builder()
                    .name("preset_1")
                    .templateVariables(                
                        DashboardTemplateVariablePresetTemplateVariableArgs.builder()
                            .name("var_1")
                            .value("host.dc")
                            .build(),
                        DashboardTemplateVariablePresetTemplateVariableArgs.builder()
                            .name("var_2")
                            .value("my_service")
                            .build())
                    .build())
                .build());
    
            // Example Free Layout
            var freeDashboard = new Dashboard("freeDashboard", DashboardArgs.builder()        
                .title("Free Layout Dashboard")
                .description("Created using the Datadog provider in Pulumi")
                .layoutType("free")
                .widgets(            
                    DashboardWidgetArgs.builder()
                        .eventStreamDefinition(DashboardWidgetEventStreamDefinitionArgs.builder()
                            .query("*")
                            .eventSize("l")
                            .title("Widget Title")
                            .titleSize(16)
                            .titleAlign("left")
                            .liveSpan("1h")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(43)
                            .width(32)
                            .x(0)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .eventTimelineDefinition(DashboardWidgetEventTimelineDefinitionArgs.builder()
                            .query("*")
                            .title("Widget Title")
                            .titleSize(16)
                            .titleAlign("left")
                            .liveSpan("1h")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(9)
                            .width(66)
                            .x(33)
                            .y(60)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .freeTextDefinition(DashboardWidgetFreeTextDefinitionArgs.builder()
                            .text("free text content")
                            .color("#d00")
                            .fontSize("36")
                            .textAlign("left")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(20)
                            .width(34)
                            .x(33)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .iframeDefinition(DashboardWidgetIframeDefinitionArgs.builder()
                            .url("http://google.com")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(46)
                            .width(39)
                            .x(101)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .imageDefinition(DashboardWidgetImageDefinitionArgs.builder()
                            .url("https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350")
                            .sizing("fit")
                            .margin("small")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(20)
                            .width(30)
                            .x(69)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .logStreamDefinition(DashboardWidgetLogStreamDefinitionArgs.builder()
                            .indexes("main")
                            .query("error")
                            .columns(                        
                                "core_host",
                                "core_service",
                                "tag_source")
                            .showDateColumn(true)
                            .showMessageColumn(true)
                            .messageDisplay("expanded-md")
                            .sort(DashboardWidgetLogStreamDefinitionSortArgs.builder()
                                .column("time")
                                .order("desc")
                                .build())
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(36)
                            .width(32)
                            .x(0)
                            .y(45)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .manageStatusDefinition(DashboardWidgetManageStatusDefinitionArgs.builder()
                            .colorPreference("text")
                            .displayFormat("countsAndList")
                            .hideZeroCounts(true)
                            .query("type:metric")
                            .showLastTriggered(false)
                            .sort("status,asc")
                            .summaryType("monitors")
                            .title("Widget Title")
                            .titleSize(16)
                            .titleAlign("left")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(40)
                            .width(30)
                            .x(101)
                            .y(48)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .traceServiceDefinition(DashboardWidgetTraceServiceDefinitionArgs.builder()
                            .displayFormat("three_column")
                            .env("datadog.com")
                            .service("alerting-cassandra")
                            .showBreakdown(true)
                            .showDistribution(true)
                            .showErrors(true)
                            .showHits(true)
                            .showLatency(false)
                            .showResourceList(false)
                            .sizeFormat("large")
                            .spanName("cassandra.query")
                            .title("alerting-cassandra #env:datadog.com")
                            .titleAlign("center")
                            .titleSize("13")
                            .liveSpan("1h")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(38)
                            .width(66)
                            .x(33)
                            .y(21)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .requests(DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                .formulas(                            
                                    DashboardWidgetTimeseriesDefinitionRequestFormulaArgs.builder()
                                        .formulaExpression("my_query_1 + my_query_2")
                                        .alias("my ff query")
                                        .build(),
                                    DashboardWidgetTimeseriesDefinitionRequestFormulaArgs.builder()
                                        .formulaExpression("my_query_1 * my_query_2")
                                        .limit(DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs.builder()
                                            .count(5)
                                            .order("desc")
                                            .build())
                                        .alias("my second ff query")
                                        .build())
                                .queries(                            
                                    DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                        .metricQuery(DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs.builder()
                                            .dataSource("metrics")
                                            .query("avg:system.cpu.user{app:general} by {env}")
                                            .name("my_query_1")
                                            .aggregator("sum")
                                            .build())
                                        .build(),
                                    DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                        .metricQuery(DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs.builder()
                                            .query("avg:system.cpu.user{app:general} by {env}")
                                            .name("my_query_2")
                                            .aggregator("sum")
                                            .build())
                                        .build())
                                .build())
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(25)
                            .x(58)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .requests(                        
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .queries(DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                        .eventQuery(DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs.builder()
                                            .name("my-query")
                                            .dataSource("logs")
                                            .indexes("days-3")
                                            .computes(DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs.builder()
                                                .aggregation("count")
                                                .build())
                                            .groupBies(DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs.builder()
                                                .facet("host")
                                                .sort(DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs.builder()
                                                    .metric("@lambda.max_memory_used")
                                                    .aggregation("avg")
                                                    .build())
                                                .limit(10)
                                                .build())
                                            .build())
                                        .build())
                                    .build(),
                                DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                    .displayType("overlay")
                                    .queries(DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                        .metricQuery(DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs.builder()
                                            .name("MyOverlay")
                                            .dataSource("metrics")
                                            .query("avg:system.cpu.user{host:COMP-QJWVM2FYT4}")
                                            .build())
                                        .build())
                                    .build())
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(28)
                            .x(29)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .requests(DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                .queries(DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                    .processQuery(DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs.builder()
                                        .dataSource("process")
                                        .textFilter("abc")
                                        .metric("process.stat.cpu.total_pct")
                                        .limit(10)
                                        .tagFilters("some_filter")
                                        .name("my_process_query")
                                        .sort("asc")
                                        .isNormalizedCpu(true)
                                        .aggregator("sum")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(28)
                            .x(0)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .requests(DashboardWidgetTimeseriesDefinitionRequestArgs.builder()
                                .formulas(DashboardWidgetTimeseriesDefinitionRequestFormulaArgs.builder()
                                    .formulaExpression("query1")
                                    .alias("my cloud cost query")
                                    .build())
                                .queries(DashboardWidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                    .cloudCostQuery(DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs.builder()
                                        .dataSource("cloud_cost")
                                        .query("sum:aws.cost.amortized{*}")
                                        .name("query1")
                                        .aggregator("sum")
                                        .build())
                                    .build())
                                .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .powerpackDefinition(DashboardWidgetPowerpackDefinitionArgs.builder()
                            .powerpackId("00000000-0000-0000-0000-000000000000")
                            .backgroundColor("blue")
                            .bannerImg("https://example.org/example.png")
                            .showTitle(true)
                            .title("Powerpack Widget")
                            .templateVariables(DashboardWidgetPowerpackDefinitionTemplateVariablesArgs.builder()
                                .controlledExternallies(DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs.builder()
                                    .name("var_2")
                                    .values("autoscaling")
                                    .prefix("service_name")
                                    .build())
                                .controlledByPowerpacks(DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs.builder()
                                    .name("var_3")
                                    .prefix("timeframe")
                                    .values(                                
                                        "default",
                                        "values",
                                        "here")
                                    .build())
                                .build())
                            .build())
                        .build())
                .templateVariables(            
                    DashboardTemplateVariableArgs.builder()
                        .name("var_1")
                        .prefix("host")
                        .default_("aws")
                        .build(),
                    DashboardTemplateVariableArgs.builder()
                        .name("var_2")
                        .prefix("service_name")
                        .default_("autoscaling")
                        .build())
                .templateVariablePresets(DashboardTemplateVariablePresetArgs.builder()
                    .name("preset_1")
                    .templateVariables(                
                        DashboardTemplateVariablePresetTemplateVariableArgs.builder()
                            .name("var_1")
                            .value("host.dc")
                            .build(),
                        DashboardTemplateVariablePresetTemplateVariableArgs.builder()
                            .name("var_2")
                            .value("my_service")
                            .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      # Example Ordered Layout
      orderedDashboard:
        type: datadog:Dashboard
        name: ordered_dashboard
        properties:
          title: Ordered Layout Dashboard
          description: Created using the Datadog provider in Pulumi
          layoutType: ordered
          widgets:
            - alertGraphDefinition:
                alertId: '895605'
                vizType: timeseries
                title: Widget Title
                liveSpan: 1h
            - alertValueDefinition:
                alertId: '895605'
                precision: 3
                unit: b
                textAlign: center
                title: Widget Title
            - alertValueDefinition:
                alertId: '895605'
                precision: 3
                unit: b
                textAlign: center
                title: Widget Title
            - changeDefinition:
                requests:
                  - q: avg:system.load.1{env:staging} by {account}
                    changeType: absolute
                    compareTo: week_before
                    increaseGood: true
                    orderBy: name
                    orderDir: desc
                    showPresent: true
                title: Widget Title
                liveSpan: 1h
            - distributionDefinition:
                requests:
                  - q: avg:system.load.1{env:staging} by {account}
                    style:
                      palette: warm
                title: Widget Title
                liveSpan: 1h
            - checkStatusDefinition:
                check: aws.ecs.agent_connected
                grouping: cluster
                groupBies:
                  - account
                  - cluster
                tags:
                  - account:demo
                  - cluster:awseb-ruthebdog-env-8-dn3m6u3gvk
                title: Widget Title
                liveSpan: 1h
            - heatmapDefinition:
                requests:
                  - q: avg:system.load.1{env:staging} by {account}
                    style:
                      palette: warm
                yaxis:
                  min: 1
                  max: 2
                  includeZero: true
                  scale: sqrt
                title: Widget Title
                liveSpan: 1h
            - hostmapDefinition:
                request:
                  fills:
                    - q: avg:system.load.1{*} by {host}
                  sizes:
                    - q: avg:memcache.uptime{*} by {host}
                nodeType: container
                groups:
                  - host
                  - region
                noGroupHosts: true
                noMetricHosts: true
                scopes:
                  - region:us-east-1
                  - aws_account:727006795293
                style:
                  palette: yellow_to_green
                  paletteFlip: true
                  fillMin: '10'
                  fillMax: '20'
                title: Widget Title
            - noteDefinition:
                content: note text
                backgroundColor: pink
                fontSize: '14'
                textAlign: center
                showTick: true
                tickEdge: left
                tickPos: 50%
            - queryValueDefinition:
                requests:
                  - q: avg:system.load.1{env:staging} by {account}
                    aggregator: sum
                    conditionalFormats:
                      - comparator: <
                        value: '2'
                        palette: white_on_green
                      - comparator: '>'
                        value: '2.2'
                        palette: white_on_red
                autoscale: true
                customUnit: xx
                precision: '4'
                textAlign: right
                title: Widget Title
                liveSpan: 1h
            - queryTableDefinition:
                requests:
                  - q: avg:system.load.1{env:staging} by {account}
                    aggregator: sum
                    limit: '10'
                    conditionalFormats:
                      - comparator: <
                        value: '2'
                        palette: white_on_green
                      - comparator: '>'
                        value: '2.2'
                        palette: white_on_red
                title: Widget Title
                liveSpan: 1h
            - scatterplotDefinition:
                request:
                  xes:
                    - q: avg:system.cpu.user{*} by {service, account}
                      aggregator: max
                  ys:
                    - q: avg:system.mem.used{*} by {service, account}
                      aggregator: min
                colorByGroups:
                  - account
                  - apm-role-group
                xaxis:
                  includeZero: true
                  label: x
                  min: '1'
                  max: '2000'
                  scale: pow
                yaxis:
                  includeZero: false
                  label: y
                  min: '5'
                  max: '2222'
                  scale: log
                title: Widget Title
                liveSpan: 1h
            - servicemapDefinition:
                service: master-db
                filters:
                  - env:prod
                  - datacenter:dc1
                title: 'env: prod, datacenter:dc1, service: master-db'
                titleSize: '16'
                titleAlign: left
            - timeseriesDefinition:
                requests:
                  - q: avg:system.cpu.user{app:general} by {env}
                    displayType: line
                    style:
                      palette: warm
                      lineType: dashed
                      lineWidth: thin
                    metadatas:
                      - expression: avg:system.cpu.user{app:general} by {env}
                        aliasName: Alpha
                  - logQuery:
                      index: mcnulty
                      computeQuery:
                        aggregation: avg
                        facet: '@duration'
                        interval: 5000
                      searchQuery: status:info
                      groupBies:
                        - facet: host
                          limit: 10
                          sortQuery:
                            aggregation: avg
                            order: desc
                            facet: '@duration'
                    displayType: area
                  - apmQuery:
                      index: apm-search
                      computeQuery:
                        aggregation: avg
                        facet: '@duration'
                        interval: 5000
                      searchQuery: type:web
                      groupBies:
                        - facet: resource_name
                          limit: 50
                          sortQuery:
                            aggregation: avg
                            order: desc
                            facet: '@string_query.interval'
                    displayType: bars
                  - processQuery:
                      metric: process.stat.cpu.total_pct
                      searchBy: error
                      filterBies:
                        - active
                      limit: 50
                    displayType: area
                markers:
                  - displayType: error dashed
                    label: ' z=6 '
                    value: y = 4
                  - displayType: ok solid
                    value: 10 < y < 999
                    label: ' x=8 '
                title: Widget Title
                showLegend: true
                legendSize: '2'
                liveSpan: 1h
                events:
                  - q: sources:test tags:1
                  - q: sources:test tags:2
                yaxis:
                  scale: log
                  includeZero: false
                  max: 100
            - toplistDefinition:
                requests:
                  - q: avg:system.cpu.user{app:general} by {env}
                    conditionalFormats:
                      - comparator: <
                        value: '2'
                        palette: white_on_green
                      - comparator: '>'
                        value: '2.2'
                        palette: white_on_red
                title: Widget Title
            - groupDefinition:
                layoutType: ordered
                title: Group Widget
                widgets:
                  - noteDefinition:
                      content: cluster note widget
                      backgroundColor: pink
                      fontSize: '14'
                      textAlign: center
                      showTick: true
                      tickEdge: left
                      tickPos: 50%
                  - alertGraphDefinition:
                      alertId: '123'
                      vizType: toplist
                      title: Alert Graph
                      liveSpan: 1h
            - serviceLevelObjectiveDefinition:
                title: Widget Title
                viewType: detail
                sloId: '56789'
                showErrorBudget: true
                viewMode: overall
                timeWindows:
                  - 7d
                  - previous_week
          templateVariables:
            - name: var_1
              prefix: host
              default: aws
            - name: var_2
              prefix: service_name
              default: autoscaling
          templateVariablePresets:
            - name: preset_1
              templateVariables:
                - name: var_1
                  value: host.dc
                - name: var_2
                  value: my_service
      # Example Free Layout
      freeDashboard:
        type: datadog:Dashboard
        name: free_dashboard
        properties:
          title: Free Layout Dashboard
          description: Created using the Datadog provider in Pulumi
          layoutType: free
          widgets:
            - eventStreamDefinition:
                query: '*'
                eventSize: l
                title: Widget Title
                titleSize: 16
                titleAlign: left
                liveSpan: 1h
              widgetLayout:
                height: 43
                width: 32
                x: 0
                y: 0
            - eventTimelineDefinition:
                query: '*'
                title: Widget Title
                titleSize: 16
                titleAlign: left
                liveSpan: 1h
              widgetLayout:
                height: 9
                width: 66
                x: 33
                y: 60
            - freeTextDefinition:
                text: free text content
                color: '#d00'
                fontSize: '36'
                textAlign: left
              widgetLayout:
                height: 20
                width: 34
                x: 33
                y: 0
            - iframeDefinition:
                url: http://google.com
              widgetLayout:
                height: 46
                width: 39
                x: 101
                y: 0
            - imageDefinition:
                url: https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350
                sizing: fit
                margin: small
              widgetLayout:
                height: 20
                width: 30
                x: 69
                y: 0
            - logStreamDefinition:
                indexes:
                  - main
                query: error
                columns:
                  - core_host
                  - core_service
                  - tag_source
                showDateColumn: true
                showMessageColumn: true
                messageDisplay: expanded-md
                sort:
                  column: time
                  order: desc
              widgetLayout:
                height: 36
                width: 32
                x: 0
                y: 45
            - manageStatusDefinition:
                colorPreference: text
                displayFormat: countsAndList
                hideZeroCounts: true
                query: type:metric
                showLastTriggered: false
                sort: status,asc
                summaryType: monitors
                title: Widget Title
                titleSize: 16
                titleAlign: left
              widgetLayout:
                height: 40
                width: 30
                x: 101
                y: 48
            - traceServiceDefinition:
                displayFormat: three_column
                env: datadog.com
                service: alerting-cassandra
                showBreakdown: true
                showDistribution: true
                showErrors: true
                showHits: true
                showLatency: false
                showResourceList: false
                sizeFormat: large
                spanName: cassandra.query
                title: 'alerting-cassandra #env:datadog.com'
                titleAlign: center
                titleSize: '13'
                liveSpan: 1h
              widgetLayout:
                height: 38
                width: 66
                x: 33
                y: 21
            - timeseriesDefinition:
                requests:
                  - formulas:
                      - formulaExpression: my_query_1 + my_query_2
                        alias: my ff query
                      - formulaExpression: my_query_1 * my_query_2
                        limit:
                          count: 5
                          order: desc
                        alias: my second ff query
                    queries:
                      - metricQuery:
                          dataSource: metrics
                          query: avg:system.cpu.user{app:general} by {env}
                          name: my_query_1
                          aggregator: sum
                      - metricQuery:
                          query: avg:system.cpu.user{app:general} by {env}
                          name: my_query_2
                          aggregator: sum
              widgetLayout:
                height: 16
                width: 25
                x: 58
                y: 83
            - timeseriesDefinition:
                requests:
                  - queries:
                      - eventQuery:
                          name: my-query
                          dataSource: logs
                          indexes:
                            - days-3
                          computes:
                            - aggregation: count
                          groupBies:
                            - facet: host
                              sort:
                                metric: '@lambda.max_memory_used'
                                aggregation: avg
                              limit: 10
                  - displayType: overlay
                    queries:
                      - metricQuery:
                          name: MyOverlay
                          dataSource: metrics
                          query: avg:system.cpu.user{host:COMP-QJWVM2FYT4}
              widgetLayout:
                height: 16
                width: 28
                x: 29
                y: 83
            - timeseriesDefinition:
                requests:
                  - queries:
                      - processQuery:
                          dataSource: process
                          textFilter: abc
                          metric: process.stat.cpu.total_pct
                          limit: 10
                          tagFilters:
                            - some_filter
                          name: my_process_query
                          sort: asc
                          isNormalizedCpu: true
                          aggregator: sum
              widgetLayout:
                height: 16
                width: 28
                x: 0
                y: 83
            - timeseriesDefinition:
                requests:
                  - formulas:
                      - formulaExpression: query1
                        alias: my cloud cost query
                    queries:
                      - cloudCostQuery:
                          dataSource: cloud_cost
                          query: sum:aws.cost.amortized{*}
                          name: query1
                          aggregator: sum
            - powerpackDefinition:
                powerpackId: 00000000-0000-0000-0000-000000000000
                backgroundColor: blue
                bannerImg: https://example.org/example.png
                showTitle: true
                title: Powerpack Widget
                templateVariables:
                  controlledExternallies:
                    - name: var_2
                      values:
                        - autoscaling
                      prefix: service_name
                  controlledByPowerpacks:
                    - name: var_3
                      prefix: timeframe
                      values:
                        - default
                        - values
                        - here
          templateVariables:
            - name: var_1
              prefix: host
              default: aws
            - name: var_2
              prefix: service_name
              default: autoscaling
          templateVariablePresets:
            - name: preset_1
              templateVariables:
                - name: var_1
                  value: host.dc
                - name: var_2
                  value: my_service
    

    Create Dashboard Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Dashboard(name: string, args: DashboardArgs, opts?: CustomResourceOptions);
    @overload
    def Dashboard(resource_name: str,
                  args: DashboardArgs,
                  opts: Optional[ResourceOptions] = None)
    
    @overload
    def Dashboard(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  layout_type: Optional[str] = None,
                  title: Optional[str] = None,
                  restricted_roles: Optional[Sequence[str]] = None,
                  is_read_only: Optional[bool] = None,
                  notify_lists: Optional[Sequence[str]] = None,
                  reflow_type: Optional[str] = None,
                  dashboard_lists: Optional[Sequence[int]] = None,
                  tags: Optional[Sequence[str]] = None,
                  template_variable_presets: Optional[Sequence[DashboardTemplateVariablePresetArgs]] = None,
                  template_variables: Optional[Sequence[DashboardTemplateVariableArgs]] = None,
                  description: Optional[str] = None,
                  url: Optional[str] = None,
                  widgets: Optional[Sequence[DashboardWidgetArgs]] = None)
    func NewDashboard(ctx *Context, name string, args DashboardArgs, opts ...ResourceOption) (*Dashboard, error)
    public Dashboard(string name, DashboardArgs args, CustomResourceOptions? opts = null)
    public Dashboard(String name, DashboardArgs args)
    public Dashboard(String name, DashboardArgs args, CustomResourceOptions options)
    
    type: datadog:Dashboard
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args DashboardArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args DashboardArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args DashboardArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args DashboardArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args DashboardArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var dashboardResource = new Datadog.Dashboard("dashboardResource", new()
    {
        LayoutType = "string",
        Title = "string",
        RestrictedRoles = new[]
        {
            "string",
        },
        NotifyLists = new[]
        {
            "string",
        },
        ReflowType = "string",
        DashboardLists = new[]
        {
            0,
        },
        Tags = new[]
        {
            "string",
        },
        TemplateVariablePresets = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariablePresetArgs
            {
                Name = "string",
                TemplateVariables = new[]
                {
                    new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                    {
                        Name = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        TemplateVariables = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariableArgs
            {
                Name = "string",
                AvailableValues = new[]
                {
                    "string",
                },
                Defaults = new[]
                {
                    "string",
                },
                Prefix = "string",
            },
        },
        Description = "string",
        Url = "string",
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "string",
                    VizType = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                {
                    AlertId = "string",
                    Precision = 0,
                    TextAlign = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Unit = "string",
                },
                ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ChangeType = "string",
                            CompareTo = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            IncreaseGood = false,
                            LogQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OrderBy = "string",
                            OrderDir = "string",
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ShowPresent = false,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetCheckStatusDefinitionArgs
                {
                    Check = "string",
                    Grouping = "string",
                    Group = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    Tags = new[]
                    {
                        "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                DistributionDefinition = new Datadog.Inputs.DashboardWidgetDistributionDefinitionArgs
                {
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            RumQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventStreamDefinition = new Datadog.Inputs.DashboardWidgetEventStreamDefinitionArgs
                {
                    Query = "string",
                    EventSize = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetEventTimelineDefinitionArgs
                {
                    Query = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FreeTextDefinition = new Datadog.Inputs.DashboardWidgetFreeTextDefinitionArgs
                {
                    Text = "string",
                    Color = "string",
                    FontSize = "string",
                    TextAlign = "string",
                },
                GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                {
                    View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                    {
                        Focus = "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                    {
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                GroupDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionArgs
                {
                    LayoutType = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    ShowTitle = false,
                    Title = "string",
                    Widgets = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetArgs
                        {
                            AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs
                            {
                                AlertId = "string",
                                VizType = "string",
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            AlertValueDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetAlertValueDefinitionArgs
                            {
                                AlertId = "string",
                                Precision = 0,
                                TextAlign = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Unit = "string",
                            },
                            ChangeDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ChangeType = "string",
                                        CompareTo = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        IncreaseGood = false,
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        OrderBy = "string",
                                        OrderDir = "string",
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",