1. Packages
  2. Packages
  3. Datadog Provider
  4. API Docs
  5. DashboardV2
Viewing docs for Datadog v5.6.0
published on Thursday, Jun 18, 2026 by Pulumi
datadog logo
Viewing docs for Datadog v5.6.0
published on Thursday, Jun 18, 2026 by Pulumi

    [BETA] Provides an updated version of the Datadog dashboard resource which improves compliance with Datadog’s dashboard API spec. This version is currently experimental and prone to changes.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as datadog from "@pulumi/datadog";
    
    // Example Ordered Layout
    const orderedDashboard = new datadog.DashboardV2("ordered_dashboard", {
        title: "Ordered Layout Dashboard",
        description: "Created using the Datadog provider in Pulumi",
        layoutType: "ordered",
        widgets: [
            {
                timeseriesDefinition: {
                    requests: [{
                        formulas: [{
                            formulaExpression: "my_query_1",
                            alias: "CPU Usage",
                        }],
                        queries: [{
                            metricQuery: {
                                dataSource: "metrics",
                                query: "avg:system.cpu.user{*} by {env}",
                                name: "my_query_1",
                                aggregator: "avg",
                            },
                        }],
                    }],
                    title: "CPU Usage by Environment",
                    liveSpan: "1h",
                },
            },
            {
                queryValueDefinition: {
                    requests: [{
                        formulas: [{
                            formulaExpression: "my_query_1",
                        }],
                        queries: [{
                            metricQuery: {
                                dataSource: "metrics",
                                query: "avg:system.load.1{*}",
                                name: "my_query_1",
                                aggregator: "avg",
                            },
                        }],
                        conditionalFormats: [
                            {
                                comparator: "<",
                                value: 2,
                                palette: "white_on_green",
                            },
                            {
                                comparator: ">",
                                value: 2.2,
                                palette: "white_on_red",
                            },
                        ],
                    }],
                    autoscale: true,
                    precision: 4,
                    textAlign: "right",
                    title: "System Load",
                    liveSpan: "1h",
                },
            },
            {
                groupDefinition: {
                    layoutType: "ordered",
                    title: "Group Widget",
                    widgets: [{
                        noteDefinition: {
                            content: "cluster note widget",
                            backgroundColor: "pink",
                            fontSize: "14",
                            textAlign: "center",
                            showTick: true,
                            tickEdge: "left",
                            tickPos: "50%",
                        },
                    }],
                },
            },
        ],
        templateVariables: [{
            name: "var_1",
            prefix: "host",
            "default": "aws",
        }],
    });
    // Example Free Layout
    const freeDashboard = new datadog.DashboardV2("free_dashboard", {
        title: "Free Layout Dashboard",
        description: "Created using the Datadog provider in Pulumi",
        layoutType: "free",
        widgets: [{
            timeseriesDefinition: {
                requests: [{
                    formulas: [{
                        formulaExpression: "my_query_1",
                    }],
                    queries: [{
                        metricQuery: {
                            dataSource: "metrics",
                            query: "avg:system.cpu.user{*} by {env}",
                            name: "my_query_1",
                            aggregator: "sum",
                        },
                    }],
                }],
            },
            widgetLayout: {
                height: 16,
                width: 25,
                x: 0,
                y: 0,
            },
        }],
        templateVariables: [{
            name: "var_1",
            prefix: "host",
            "default": "aws",
        }],
    });
    
    import pulumi
    import pulumi_datadog as datadog
    
    # Example Ordered Layout
    ordered_dashboard = datadog.DashboardV2("ordered_dashboard",
        title="Ordered Layout Dashboard",
        description="Created using the Datadog provider in Pulumi",
        layout_type="ordered",
        widgets=[
            {
                "timeseries_definition": {
                    "requests": [{
                        "formulas": [{
                            "formula_expression": "my_query_1",
                            "alias": "CPU Usage",
                        }],
                        "queries": [{
                            "metric_query": {
                                "data_source": "metrics",
                                "query": "avg:system.cpu.user{*} by {env}",
                                "name": "my_query_1",
                                "aggregator": "avg",
                            },
                        }],
                    }],
                    "title": "CPU Usage by Environment",
                    "live_span": "1h",
                },
            },
            {
                "query_value_definition": {
                    "requests": [{
                        "formulas": [{
                            "formula_expression": "my_query_1",
                        }],
                        "queries": [{
                            "metric_query": {
                                "data_source": "metrics",
                                "query": "avg:system.load.1{*}",
                                "name": "my_query_1",
                                "aggregator": "avg",
                            },
                        }],
                        "conditional_formats": [
                            {
                                "comparator": "<",
                                "value": float(2),
                                "palette": "white_on_green",
                            },
                            {
                                "comparator": ">",
                                "value": 2.2,
                                "palette": "white_on_red",
                            },
                        ],
                    }],
                    "autoscale": True,
                    "precision": 4,
                    "text_align": "right",
                    "title": "System Load",
                    "live_span": "1h",
                },
            },
            {
                "group_definition": {
                    "layout_type": "ordered",
                    "title": "Group Widget",
                    "widgets": [{
                        "note_definition": {
                            "content": "cluster note widget",
                            "background_color": "pink",
                            "font_size": "14",
                            "text_align": "center",
                            "show_tick": True,
                            "tick_edge": "left",
                            "tick_pos": "50%",
                        },
                    }],
                },
            },
        ],
        template_variables=[{
            "name": "var_1",
            "prefix": "host",
            "default": "aws",
        }])
    # Example Free Layout
    free_dashboard = datadog.DashboardV2("free_dashboard",
        title="Free Layout Dashboard",
        description="Created using the Datadog provider in Pulumi",
        layout_type="free",
        widgets=[{
            "timeseries_definition": {
                "requests": [{
                    "formulas": [{
                        "formula_expression": "my_query_1",
                    }],
                    "queries": [{
                        "metric_query": {
                            "data_source": "metrics",
                            "query": "avg:system.cpu.user{*} by {env}",
                            "name": "my_query_1",
                            "aggregator": "sum",
                        },
                    }],
                }],
            },
            "widget_layout": {
                "height": 16,
                "width": 25,
                "x": 0,
                "y": 0,
            },
        }],
        template_variables=[{
            "name": "var_1",
            "prefix": "host",
            "default": "aws",
        }])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-datadog/sdk/v5/go/datadog"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// Example Ordered Layout
    		_, err := datadog.NewDashboardV2(ctx, "ordered_dashboard", &datadog.DashboardV2Args{
    			Title:       pulumi.String("Ordered Layout Dashboard"),
    			Description: pulumi.String("Created using the Datadog provider in Pulumi"),
    			LayoutType:  pulumi.String("ordered"),
    			Widgets: datadog.DashboardV2WidgetArray{
    				&datadog.DashboardV2WidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardV2WidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardV2WidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardV2WidgetTimeseriesDefinitionRequestArgs{
    								Formulas: datadog.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("my_query_1"),
    										Alias:             pulumi.String("CPU Usage"),
    									},
    								},
    								Queries: datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    											DataSource: pulumi.String("metrics"),
    											Query:      pulumi.String("avg:system.cpu.user{*} by {env}"),
    											Name:       pulumi.String("my_query_1"),
    											Aggregator: pulumi.String("avg"),
    										},
    									},
    								},
    							},
    						},
    						Title:    pulumi.String("CPU Usage by Environment"),
    						LiveSpan: pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardV2WidgetArgs{
    					QueryValueDefinition: &datadog.DashboardV2WidgetQueryValueDefinitionArgs{
    						Requests: datadog.DashboardV2WidgetQueryValueDefinitionRequestArray{
    							&datadog.DashboardV2WidgetQueryValueDefinitionRequestArgs{
    								Formulas: datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("my_query_1"),
    									},
    								},
    								Queries: datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs{
    											DataSource: pulumi.String("metrics"),
    											Query:      pulumi.String("avg:system.load.1{*}"),
    											Name:       pulumi.String("my_query_1"),
    											Aggregator: pulumi.String("avg"),
    										},
    									},
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String("<"),
    										Value:      pulumi.Float64(2),
    										Palette:    pulumi.String("white_on_green"),
    									},
    									&datadog.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs{
    										Comparator: pulumi.String(">"),
    										Value:      pulumi.Float64(2.2),
    										Palette:    pulumi.String("white_on_red"),
    									},
    								},
    							},
    						},
    						Autoscale: pulumi.Bool(true),
    						Precision: pulumi.Int(4),
    						TextAlign: pulumi.String("right"),
    						Title:     pulumi.String("System Load"),
    						LiveSpan:  pulumi.String("1h"),
    					},
    				},
    				&datadog.DashboardV2WidgetArgs{
    					GroupDefinition: &datadog.DashboardV2WidgetGroupDefinitionArgs{
    						LayoutType: pulumi.String("ordered"),
    						Title:      pulumi.String("Group Widget"),
    						Widgets: datadog.DashboardV2WidgetGroupDefinitionWidgetArray{
    							&datadog.DashboardV2WidgetGroupDefinitionWidgetArgs{
    								NoteDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs{
    									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%"),
    								},
    							},
    						},
    					},
    				},
    			},
    			TemplateVariables: datadog.DashboardV2TemplateVariableArray{
    				&datadog.DashboardV2TemplateVariableArgs{
    					Name:    pulumi.String("var_1"),
    					Prefix:  pulumi.String("host"),
    					Default: pulumi.String("aws"),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Free Layout
    		_, err = datadog.NewDashboardV2(ctx, "free_dashboard", &datadog.DashboardV2Args{
    			Title:       pulumi.String("Free Layout Dashboard"),
    			Description: pulumi.String("Created using the Datadog provider in Pulumi"),
    			LayoutType:  pulumi.String("free"),
    			Widgets: datadog.DashboardV2WidgetArray{
    				&datadog.DashboardV2WidgetArgs{
    					TimeseriesDefinition: &datadog.DashboardV2WidgetTimeseriesDefinitionArgs{
    						Requests: datadog.DashboardV2WidgetTimeseriesDefinitionRequestArray{
    							&datadog.DashboardV2WidgetTimeseriesDefinitionRequestArgs{
    								Formulas: datadog.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("my_query_1"),
    									},
    								},
    								Queries: datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs{
    										MetricQuery: &datadog.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    											DataSource: pulumi.String("metrics"),
    											Query:      pulumi.String("avg:system.cpu.user{*} by {env}"),
    											Name:       pulumi.String("my_query_1"),
    											Aggregator: pulumi.String("sum"),
    										},
    									},
    								},
    							},
    						},
    					},
    					WidgetLayout: &datadog.DashboardV2WidgetWidgetLayoutArgs{
    						Height: pulumi.Int(16),
    						Width:  pulumi.Int(25),
    						X:      pulumi.Int(0),
    						Y:      pulumi.Int(0),
    					},
    				},
    			},
    			TemplateVariables: datadog.DashboardV2TemplateVariableArray{
    				&datadog.DashboardV2TemplateVariableArgs{
    					Name:    pulumi.String("var_1"),
    					Prefix:  pulumi.String("host"),
    					Default: pulumi.String("aws"),
    				},
    			},
    		})
    		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.DashboardV2("ordered_dashboard", new()
        {
            Title = "Ordered Layout Dashboard",
            Description = "Created using the Datadog provider in Pulumi",
            LayoutType = "ordered",
            Widgets = new[]
            {
                new Datadog.Inputs.DashboardV2WidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "my_query_1",
                                        Alias = "CPU Usage",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                        {
                                            DataSource = "metrics",
                                            Query = "avg:system.cpu.user{*} by {env}",
                                            Name = "my_query_1",
                                            Aggregator = "avg",
                                        },
                                    },
                                },
                            },
                        },
                        Title = "CPU Usage by Environment",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardV2WidgetArgs
                {
                    QueryValueDefinition = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "my_query_1",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                        {
                                            DataSource = "metrics",
                                            Query = "avg:system.load.1{*}",
                                            Name = "my_query_1",
                                            Aggregator = "avg",
                                        },
                                    },
                                },
                                ConditionalFormats = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = "<",
                                        Value = 2,
                                        Palette = "white_on_green",
                                    },
                                    new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs
                                    {
                                        Comparator = ">",
                                        Value = 2.2,
                                        Palette = "white_on_red",
                                    },
                                },
                            },
                        },
                        Autoscale = true,
                        Precision = 4,
                        TextAlign = "right",
                        Title = "System Load",
                        LiveSpan = "1h",
                    },
                },
                new Datadog.Inputs.DashboardV2WidgetArgs
                {
                    GroupDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionArgs
                    {
                        LayoutType = "ordered",
                        Title = "Group Widget",
                        Widgets = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetArgs
                            {
                                NoteDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs
                                {
                                    Content = "cluster note widget",
                                    BackgroundColor = "pink",
                                    FontSize = "14",
                                    TextAlign = "center",
                                    ShowTick = true,
                                    TickEdge = "left",
                                    TickPos = "50%",
                                },
                            },
                        },
                    },
                },
            },
            TemplateVariables = new[]
            {
                new Datadog.Inputs.DashboardV2TemplateVariableArgs
                {
                    Name = "var_1",
                    Prefix = "host",
                    Default = "aws",
                },
            },
        });
    
        // Example Free Layout
        var freeDashboard = new Datadog.DashboardV2("free_dashboard", new()
        {
            Title = "Free Layout Dashboard",
            Description = "Created using the Datadog provider in Pulumi",
            LayoutType = "free",
            Widgets = new[]
            {
                new Datadog.Inputs.DashboardV2WidgetArgs
                {
                    TimeseriesDefinition = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionArgs
                    {
                        Requests = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs
                                    {
                                        FormulaExpression = "my_query_1",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs
                                    {
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                        {
                                            DataSource = "metrics",
                                            Query = "avg:system.cpu.user{*} by {env}",
                                            Name = "my_query_1",
                                            Aggregator = "sum",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    WidgetLayout = new Datadog.Inputs.DashboardV2WidgetWidgetLayoutArgs
                    {
                        Height = 16,
                        Width = 25,
                        X = 0,
                        Y = 0,
                    },
                },
            },
            TemplateVariables = new[]
            {
                new Datadog.Inputs.DashboardV2TemplateVariableArgs
                {
                    Name = "var_1",
                    Prefix = "host",
                    Default = "aws",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.datadog.DashboardV2;
    import com.pulumi.datadog.DashboardV2Args;
    import com.pulumi.datadog.inputs.DashboardV2WidgetArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetTimeseriesDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetTimeseriesDefinitionRequestArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionRequestArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetGroupDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetGroupDefinitionWidgetArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs;
    import com.pulumi.datadog.inputs.DashboardV2TemplateVariableArgs;
    import com.pulumi.datadog.inputs.DashboardV2WidgetWidgetLayoutArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 DashboardV2("orderedDashboard", DashboardV2Args.builder()
                .title("Ordered Layout Dashboard")
                .description("Created using the Datadog provider in Pulumi")
                .layoutType("ordered")
                .widgets(            
                    DashboardV2WidgetArgs.builder()
                        .timeseriesDefinition(DashboardV2WidgetTimeseriesDefinitionArgs.builder()
                            .requests(DashboardV2WidgetTimeseriesDefinitionRequestArgs.builder()
                                .formulas(DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs.builder()
                                    .formulaExpression("my_query_1")
                                    .alias("CPU Usage")
                                    .build())
                                .queries(DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                    .metricQuery(DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs.builder()
                                        .dataSource("metrics")
                                        .query("avg:system.cpu.user{*} by {env}")
                                        .name("my_query_1")
                                        .aggregator("avg")
                                        .build())
                                    .build())
                                .build())
                            .title("CPU Usage by Environment")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardV2WidgetArgs.builder()
                        .queryValueDefinition(DashboardV2WidgetQueryValueDefinitionArgs.builder()
                            .requests(DashboardV2WidgetQueryValueDefinitionRequestArgs.builder()
                                .formulas(DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs.builder()
                                    .formulaExpression("my_query_1")
                                    .build())
                                .queries(DashboardV2WidgetQueryValueDefinitionRequestQueryArgs.builder()
                                    .metricQuery(DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs.builder()
                                        .dataSource("metrics")
                                        .query("avg:system.load.1{*}")
                                        .name("my_query_1")
                                        .aggregator("avg")
                                        .build())
                                    .build())
                                .conditionalFormats(                            
                                    DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator("<")
                                        .value(2.0)
                                        .palette("white_on_green")
                                        .build(),
                                    DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs.builder()
                                        .comparator(">")
                                        .value(2.2)
                                        .palette("white_on_red")
                                        .build())
                                .build())
                            .autoscale(true)
                            .precision(4)
                            .textAlign("right")
                            .title("System Load")
                            .liveSpan("1h")
                            .build())
                        .build(),
                    DashboardV2WidgetArgs.builder()
                        .groupDefinition(DashboardV2WidgetGroupDefinitionArgs.builder()
                            .layoutType("ordered")
                            .title("Group Widget")
                            .widgets(DashboardV2WidgetGroupDefinitionWidgetArgs.builder()
                                .noteDefinition(DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs.builder()
                                    .content("cluster note widget")
                                    .backgroundColor("pink")
                                    .fontSize("14")
                                    .textAlign("center")
                                    .showTick(true)
                                    .tickEdge("left")
                                    .tickPos("50%")
                                    .build())
                                .build())
                            .build())
                        .build())
                .templateVariables(DashboardV2TemplateVariableArgs.builder()
                    .name("var_1")
                    .prefix("host")
                    .default_("aws")
                    .build())
                .build());
    
            // Example Free Layout
            var freeDashboard = new DashboardV2("freeDashboard", DashboardV2Args.builder()
                .title("Free Layout Dashboard")
                .description("Created using the Datadog provider in Pulumi")
                .layoutType("free")
                .widgets(DashboardV2WidgetArgs.builder()
                    .timeseriesDefinition(DashboardV2WidgetTimeseriesDefinitionArgs.builder()
                        .requests(DashboardV2WidgetTimeseriesDefinitionRequestArgs.builder()
                            .formulas(DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs.builder()
                                .formulaExpression("my_query_1")
                                .build())
                            .queries(DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs.builder()
                                .metricQuery(DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs.builder()
                                    .dataSource("metrics")
                                    .query("avg:system.cpu.user{*} by {env}")
                                    .name("my_query_1")
                                    .aggregator("sum")
                                    .build())
                                .build())
                            .build())
                        .build())
                    .widgetLayout(DashboardV2WidgetWidgetLayoutArgs.builder()
                        .height(16)
                        .width(25)
                        .x(0)
                        .y(0)
                        .build())
                    .build())
                .templateVariables(DashboardV2TemplateVariableArgs.builder()
                    .name("var_1")
                    .prefix("host")
                    .default_("aws")
                    .build())
                .build());
    
        }
    }
    
    resources:
      # Example Ordered Layout
      orderedDashboard:
        type: datadog:DashboardV2
        name: ordered_dashboard
        properties:
          title: Ordered Layout Dashboard
          description: Created using the Datadog provider in Pulumi
          layoutType: ordered
          widgets:
            - timeseriesDefinition:
                requests:
                  - formulas:
                      - formulaExpression: my_query_1
                        alias: CPU Usage
                    queries:
                      - metricQuery:
                          dataSource: metrics
                          query: avg:system.cpu.user{*} by {env}
                          name: my_query_1
                          aggregator: avg
                title: CPU Usage by Environment
                liveSpan: 1h
            - queryValueDefinition:
                requests:
                  - formulas:
                      - formulaExpression: my_query_1
                    queries:
                      - metricQuery:
                          dataSource: metrics
                          query: avg:system.load.1{*}
                          name: my_query_1
                          aggregator: avg
                    conditionalFormats:
                      - comparator: <
                        value: '2'
                        palette: white_on_green
                      - comparator: '>'
                        value: '2.2'
                        palette: white_on_red
                autoscale: true
                precision: '4'
                textAlign: right
                title: System Load
                liveSpan: 1h
            - groupDefinition:
                layoutType: ordered
                title: Group Widget
                widgets:
                  - noteDefinition:
                      content: cluster note widget
                      backgroundColor: pink
                      fontSize: '14'
                      textAlign: center
                      showTick: true
                      tickEdge: left
                      tickPos: 50%
          templateVariables:
            - name: var_1
              prefix: host
              default: aws
      # Example Free Layout
      freeDashboard:
        type: datadog:DashboardV2
        name: free_dashboard
        properties:
          title: Free Layout Dashboard
          description: Created using the Datadog provider in Pulumi
          layoutType: free
          widgets:
            - timeseriesDefinition:
                requests:
                  - formulas:
                      - formulaExpression: my_query_1
                    queries:
                      - metricQuery:
                          dataSource: metrics
                          query: avg:system.cpu.user{*} by {env}
                          name: my_query_1
                          aggregator: sum
              widgetLayout:
                height: 16
                width: 25
                x: 0
                y: 0
          templateVariables:
            - name: var_1
              prefix: host
              default: aws
    
    pulumi {
      required_providers {
        datadog = {
          source = "pulumi/datadog"
        }
      }
    }
    
    # Example Ordered Layout
    resource "datadog_dashboardv2" "ordered_dashboard" {
      title       = "Ordered Layout Dashboard"
      description = "Created using the Datadog provider in Pulumi"
      layout_type = "ordered"
      widgets {
        timeseries_definition = {
          requests = [{
            "formulas" = [{
              "formulaExpression" = "my_query_1"
              "alias"             = "CPU Usage"
            }]
            "queries" = [{
              "metricQuery" = {
                "dataSource" = "metrics"
                "query"      = "avg:system.cpu.user{*} by {env}"
                "name"       = "my_query_1"
                "aggregator" = "avg"
              }
            }]
          }]
          title     = "CPU Usage by Environment"
          live_span = "1h"
        }
      }
      widgets {
        query_value_definition = {
          requests = [{
            "formulas" = [{
              "formulaExpression" = "my_query_1"
            }]
            "queries" = [{
              "metricQuery" = {
                "dataSource" = "metrics"
                "query"      = "avg:system.load.1{*}"
                "name"       = "my_query_1"
                "aggregator" = "avg"
              }
            }]
            "conditionalFormats" = [{
              "comparator" = "<"
              "value"      = "2"
              "palette"    = "white_on_green"
              }, {
              "comparator" = ">"
              "value"      = "2.2"
              "palette"    = "white_on_red"
            }]
          }]
          autoscale  = true
          precision  = "4"
          text_align = "right"
          title      = "System Load"
          live_span  = "1h"
        }
      }
      widgets {
        group_definition = {
          layout_type = "ordered"
          title       = "Group Widget"
          widgets = [{
            "noteDefinition" = {
              "content"         = "cluster note widget"
              "backgroundColor" = "pink"
              "fontSize"        = "14"
              "textAlign"       = "center"
              "showTick"        = true
              "tickEdge"        = "left"
              "tickPos"         = "50%"
            }
          }]
        }
      }
      template_variables {
        name    = "var_1"
        prefix  = "host"
        default = "aws"
      }
    }
    # Example Free Layout
    resource "datadog_dashboardv2" "free_dashboard" {
      title       = "Free Layout Dashboard"
      description = "Created using the Datadog provider in Pulumi"
      layout_type = "free"
      widgets {
        timeseries_definition = {
          requests = [{
            "formulas" = [{
              "formulaExpression" = "my_query_1"
            }]
            "queries" = [{
              "metricQuery" = {
                "dataSource" = "metrics"
                "query"      = "avg:system.cpu.user{*} by {env}"
                "name"       = "my_query_1"
                "aggregator" = "sum"
              }
            }]
          }]
        }
        widget_layout = {
          height = 16
          width  = 25
          x      = 0
          y      = 0
        }
      }
      template_variables {
        name    = "var_1"
        prefix  = "host"
        default = "aws"
      }
    }
    

    Create DashboardV2 Resource

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

    Constructor syntax

    new DashboardV2(name: string, args: DashboardV2Args, opts?: CustomResourceOptions);
    @overload
    def DashboardV2(resource_name: str,
                    args: DashboardV2Args,
                    opts: Optional[ResourceOptions] = None)
    
    @overload
    def DashboardV2(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    layout_type: Optional[str] = None,
                    title: Optional[str] = None,
                    reflow_type: Optional[str] = None,
                    is_read_only: Optional[bool] = None,
                    description: Optional[str] = None,
                    notify_lists: Optional[Sequence[str]] = None,
                    dashboard_lists: Optional[Sequence[int]] = None,
                    restricted_roles: Optional[Sequence[str]] = None,
                    tabs: Optional[Sequence[DashboardV2TabArgs]] = None,
                    tags: Optional[Sequence[str]] = None,
                    template_variable_presets: Optional[Sequence[DashboardV2TemplateVariablePresetArgs]] = None,
                    template_variables: Optional[Sequence[DashboardV2TemplateVariableArgs]] = None,
                    dashboard_lists_removeds: Optional[Sequence[int]] = None,
                    url: Optional[str] = None,
                    widgets: Optional[Sequence[DashboardV2WidgetArgs]] = None)
    func NewDashboardV2(ctx *Context, name string, args DashboardV2Args, opts ...ResourceOption) (*DashboardV2, error)
    public DashboardV2(string name, DashboardV2Args args, CustomResourceOptions? opts = null)
    public DashboardV2(String name, DashboardV2Args args)
    public DashboardV2(String name, DashboardV2Args args, CustomResourceOptions options)
    
    type: datadog:DashboardV2
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "datadog_dashboardv2" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args DashboardV2Args
    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 DashboardV2Args
    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 DashboardV2Args
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args DashboardV2Args
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args DashboardV2Args
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

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

    var dashboardV2Resource = new Datadog.DashboardV2("dashboardV2Resource", new()
    {
        LayoutType = "string",
        Title = "string",
        ReflowType = "string",
        Description = "string",
        NotifyLists = new[]
        {
            "string",
        },
        DashboardLists = new[]
        {
            0,
        },
        RestrictedRoles = new[]
        {
            "string",
        },
        Tabs = new[]
        {
            new Datadog.Inputs.DashboardV2TabArgs
            {
                Name = "string",
                WidgetIds = new[]
                {
                    "string",
                },
                Id = "string",
            },
        },
        Tags = new[]
        {
            "string",
        },
        TemplateVariablePresets = new[]
        {
            new Datadog.Inputs.DashboardV2TemplateVariablePresetArgs
            {
                Name = "string",
                TemplateVariables = new[]
                {
                    new Datadog.Inputs.DashboardV2TemplateVariablePresetTemplateVariableArgs
                    {
                        Name = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        TemplateVariables = new[]
        {
            new Datadog.Inputs.DashboardV2TemplateVariableArgs
            {
                Name = "string",
                AvailableValues = new[]
                {
                    "string",
                },
                Defaults = new[]
                {
                    "string",
                },
                Prefix = "string",
                Type = "string",
            },
        },
        DashboardListsRemoveds = new[]
        {
            0,
        },
        Url = "string",
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardV2WidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardV2WidgetAlertGraphDefinitionArgs
                {
                    AlertId = "string",
                    VizType = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetAlertGraphDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetAlertGraphDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetAlertGraphDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                AlertValueDefinition = new Datadog.Inputs.DashboardV2WidgetAlertValueDefinitionArgs
                {
                    AlertId = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Precision = 0,
                    TextAlign = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetAlertValueDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetAlertValueDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetAlertValueDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Unit = "string",
                },
                BarChartDefinition = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Request = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestArgs
                    {
                        ConditionalFormats = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestConditionalFormatArgs
                            {
                                Comparator = "string",
                                Palette = "string",
                                Value = 0,
                                CustomBgColor = "string",
                                CustomFgColor = "string",
                                HideValue = false,
                                ImageUrl = "string",
                                Metric = "string",
                                Timeframe = "string",
                            },
                        },
                        Formulas = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaArgs
                            {
                                FormulaExpression = "string",
                                Alias = "string",
                                CellDisplayMode = "string",
                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                {
                                    TrendType = "string",
                                    YScale = "string",
                                },
                                ConditionalFormats = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaConditionalFormatArgs
                                    {
                                        Comparator = "string",
                                        Palette = "string",
                                        Value = 0,
                                        CustomBgColor = "string",
                                        CustomFgColor = "string",
                                        HideValue = false,
                                        ImageUrl = "string",
                                        Metric = "string",
                                        Timeframe = "string",
                                    },
                                },
                                Limit = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaLimitArgs
                                {
                                    Count = 0,
                                    Order = "string",
                                },
                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatArgs
                                {
                                    Unit = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitArgs
                                    {
                                        Canonical = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                        {
                                            PerUnitName = "string",
                                            UnitName = "string",
                                        },
                                        Custom = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                        {
                                            Label = "string",
                                        },
                                    },
                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                    {
                                        UnitName = "string",
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestFormulaStyleArgs
                                {
                                    Palette = "string",
                                    PaletteIndex = 0,
                                },
                            },
                        },
                        Queries = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryArgs
                            {
                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryApmDependencyStatsQueryArgs
                                {
                                    DataSource = "string",
                                    Env = "string",
                                    Name = "string",
                                    OperationName = "string",
                                    ResourceName = "string",
                                    Service = "string",
                                    Stat = "string",
                                    CrossOrgUuids = "string",
                                    IsUpstream = false,
                                    PrimaryTagName = "string",
                                    PrimaryTagValue = "string",
                                },
                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryApmResourceStatsQueryArgs
                                {
                                    DataSource = "string",
                                    Env = "string",
                                    Name = "string",
                                    Service = "string",
                                    Stat = "string",
                                    CrossOrgUuids = "string",
                                    GroupBies = new[]
                                    {
                                        "string",
                                    },
                                    OperationName = "string",
                                    PrimaryTagName = "string",
                                    PrimaryTagValue = "string",
                                    ResourceName = "string",
                                },
                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryCloudCostQueryArgs
                                {
                                    DataSource = "string",
                                    Name = "string",
                                    Query = "string",
                                    Aggregator = "string",
                                    CrossOrgUuids = "string",
                                },
                                EventQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryArgs
                                {
                                    Computes = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryComputeArgs
                                        {
                                            Aggregation = "string",
                                            Interval = 0,
                                            Metric = "string",
                                        },
                                    },
                                    DataSource = "string",
                                    Name = "string",
                                    CrossOrgUuids = "string",
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupBySortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                    },
                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                    {
                                        Fields = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        Sort = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                        {
                                            Aggregation = "string",
                                            Metric = "string",
                                            Order = "string",
                                        },
                                    },
                                    Indexes = new[]
                                    {
                                        "string",
                                    },
                                    Search = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryEventQuerySearchArgs
                                    {
                                        Query = "string",
                                    },
                                    Storage = "string",
                                },
                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryMetricQueryArgs
                                {
                                    Name = "string",
                                    Query = "string",
                                    Aggregator = "string",
                                    CrossOrgUuids = "string",
                                    DataSource = "string",
                                    SemanticMode = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQueryProcessQueryArgs
                                {
                                    DataSource = "string",
                                    Metric = "string",
                                    Name = "string",
                                    Aggregator = "string",
                                    CrossOrgUuids = "string",
                                    IsNormalizedCpu = false,
                                    Limit = 0,
                                    Sort = "string",
                                    TagFilters = new[]
                                    {
                                        "string",
                                    },
                                    TextFilter = "string",
                                },
                                SloQuery = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestQuerySloQueryArgs
                                {
                                    DataSource = "string",
                                    Measure = "string",
                                    SloId = "string",
                                    AdditionalQueryFilters = "string",
                                    CrossOrgUuids = "string",
                                    GroupMode = "string",
                                    Name = "string",
                                    SloQueryType = "string",
                                },
                            },
                        },
                        Sort = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestSortArgs
                        {
                            Count = 0,
                            OrderBies = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestSortOrderByArgs
                                {
                                    FormulaSort = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestSortOrderByFormulaSortArgs
                                    {
                                        Index = 0,
                                        Order = "string",
                                    },
                                    GroupSort = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestSortOrderByGroupSortArgs
                                    {
                                        Name = "string",
                                        Order = "string",
                                    },
                                },
                            },
                        },
                        Style = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionRequestStyleArgs
                        {
                            OrderBy = "string",
                            Palette = "string",
                        },
                    },
                    Style = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionStyleArgs
                    {
                        Display = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionStyleDisplayArgs
                        {
                            Flat = null,
                            Stacked = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionStyleDisplayStackedArgs
                            {
                                Legend = "string",
                            },
                        },
                        Palette = "string",
                        Scaling = "string",
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetBarChartDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ChangeDefinition = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetChangeDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestArgs
                        {
                            ChangeType = "string",
                            CompareTo = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            IncreaseGood = false,
                            OrderBy = "string",
                            OrderDir = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            ShowPresent = false,
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetChangeDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                CheckStatusDefinition = new Datadog.Inputs.DashboardV2WidgetCheckStatusDefinitionArgs
                {
                    Check = "string",
                    Grouping = "string",
                    Description = "string",
                    Group = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Tags = new[]
                    {
                        "string",
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetCheckStatusDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetCheckStatusDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetCheckStatusDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                DistributionDefinition = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionArgs
                {
                    Description = "string",
                    HideIncompleteCostData = false,
                    LegendSize = "string",
                    LiveSpan = "string",
                    Markers = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionMarkerArgs
                        {
                            Value = "string",
                            DisplayType = "string",
                            Label = "string",
                            Time = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestArgs
                        {
                            ApmStatsQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            HistogramQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryArgs
                            {
                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryApmResourceStatsQueryArgs
                                {
                                    DataSource = "string",
                                    Env = "string",
                                    Name = "string",
                                    Service = "string",
                                    Stat = "string",
                                    CrossOrgUuids = "string",
                                    GroupBies = new[]
                                    {
                                        "string",
                                    },
                                    OperationName = "string",
                                    PrimaryTagName = "string",
                                    PrimaryTagValue = "string",
                                    ResourceName = "string",
                                },
                                EventQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryArgs
                                {
                                    Computes = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArgs
                                        {
                                            Aggregation = "string",
                                            Interval = 0,
                                            Metric = "string",
                                        },
                                    },
                                    DataSource = "string",
                                    Name = "string",
                                    CrossOrgUuids = "string",
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupBySortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                    },
                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsArgs
                                    {
                                        Fields = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        Sort = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsSortArgs
                                        {
                                            Aggregation = "string",
                                            Metric = "string",
                                            Order = "string",
                                        },
                                    },
                                    Indexes = new[]
                                    {
                                        "string",
                                    },
                                    Search = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQuerySearchArgs
                                    {
                                        Query = "string",
                                    },
                                    Storage = "string",
                                },
                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryMetricQueryArgs
                                {
                                    Name = "string",
                                    Query = "string",
                                    Aggregator = "string",
                                    CrossOrgUuids = "string",
                                    DataSource = "string",
                                    SemanticMode = "string",
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RequestType = "string",
                            Style = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionRequestStyleArgs
                            {
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionXaxisArgs
                    {
                        IncludeZero = false,
                        Max = "string",
                        Min = "string",
                        NumBuckets = 0,
                        Scale = "string",
                    },
                    Yaxis = new Datadog.Inputs.DashboardV2WidgetDistributionDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                EventStreamDefinition = new Datadog.Inputs.DashboardV2WidgetEventStreamDefinitionArgs
                {
                    Query = "string",
                    Description = "string",
                    EventSize = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetEventStreamDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetEventStreamDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetEventStreamDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventTimelineDefinition = new Datadog.Inputs.DashboardV2WidgetEventTimelineDefinitionArgs
                {
                    Query = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetEventTimelineDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetEventTimelineDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetEventTimelineDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FreeTextDefinition = new Datadog.Inputs.DashboardV2WidgetFreeTextDefinitionArgs
                {
                    Text = "string",
                    BackgroundColor = "string",
                    Color = "string",
                    Description = "string",
                    FontSize = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    TextAlign = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetFreeTextDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetFreeTextDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetFreeTextDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FunnelDefinition = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionArgs
                {
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Request = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionRequestArgs
                    {
                        Query = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionRequestQueryArgs
                        {
                            DataSource = "string",
                            QueryString = "string",
                            Steps = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionRequestQueryStepArgs
                                {
                                    Facet = "string",
                                    Value = "string",
                                },
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetFunnelDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                GeomapDefinition = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    Style = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionStyleArgs
                    {
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    View = new Datadog.Inputs.DashboardV2WidgetGeomapDefinitionViewArgs
                    {
                        Focus = "string",
                    },
                },
                GroupDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionArgs
                {
                    LayoutType = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    ShowTitle = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Widgets = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetArgs
                        {
                            AlertGraphDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionArgs
                            {
                                AlertId = "string",
                                VizType = "string",
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            AlertValueDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionArgs
                            {
                                AlertId = "string",
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Precision = 0,
                                TextAlign = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Unit = "string",
                            },
                            BarChartDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Request = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestArgs
                                {
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortArgs
                                    {
                                        Count = 0,
                                        OrderBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByArgs
                                            {
                                                FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByFormulaSortArgs
                                                {
                                                    Index = 0,
                                                    Order = "string",
                                                },
                                                GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByGroupSortArgs
                                                {
                                                    Name = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestStyleArgs
                                    {
                                        OrderBy = "string",
                                        Palette = "string",
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleArgs
                                {
                                    Display = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleDisplayArgs
                                    {
                                        Flat = null,
                                        Stacked = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleDisplayStackedArgs
                                        {
                                            Legend = "string",
                                        },
                                    },
                                    Palette = "string",
                                    Scaling = "string",
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ChangeDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestArgs
                                    {
                                        ChangeType = "string",
                                        CompareTo = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        IncreaseGood = false,
                                        OrderBy = "string",
                                        OrderDir = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        ShowPresent = false,
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            CheckStatusDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionArgs
                            {
                                Check = "string",
                                Grouping = "string",
                                Description = "string",
                                Group = "string",
                                GroupBies = new[]
                                {
                                    "string",
                                },
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Tags = new[]
                                {
                                    "string",
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            DistributionDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionArgs
                            {
                                Description = "string",
                                HideIncompleteCostData = false,
                                LegendSize = "string",
                                LiveSpan = "string",
                                Markers = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionMarkerArgs
                                    {
                                        Value = "string",
                                        DisplayType = "string",
                                        Label = "string",
                                        Time = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestArgs
                                    {
                                        ApmStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryArgs
                                        {
                                            Env = "string",
                                            Name = "string",
                                            PrimaryTag = "string",
                                            RowType = "string",
                                            Service = "string",
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                                {
                                                    Name = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Resource = "string",
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        HistogramQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryArgs
                                        {
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RequestType = "string",
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestStyleArgs
                                        {
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionXaxisArgs
                                {
                                    IncludeZero = false,
                                    Max = "string",
                                    Min = "string",
                                    NumBuckets = 0,
                                    Scale = "string",
                                },
                                Yaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            EventStreamDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionArgs
                            {
                                Query = "string",
                                Description = "string",
                                EventSize = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            EventTimelineDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionArgs
                            {
                                Query = "string",
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            FreeTextDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionArgs
                            {
                                Text = "string",
                                BackgroundColor = "string",
                                Color = "string",
                                Description = "string",
                                FontSize = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                TextAlign = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            FunnelDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionArgs
                            {
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Request = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestArgs
                                {
                                    Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestQueryArgs
                                    {
                                        DataSource = "string",
                                        QueryString = "string",
                                        Steps = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestQueryStepArgs
                                            {
                                                Facet = "string",
                                                Value = "string",
                                            },
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            GeomapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionStyleArgs
                                {
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                View = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionViewArgs
                                {
                                    Focus = "string",
                                },
                            },
                            HeatmapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                Events = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionEventArgs
                                    {
                                        Q = "string",
                                        TagsExecution = "string",
                                    },
                                },
                                HideIncompleteCostData = false,
                                LegendSize = "string",
                                LiveSpan = "string",
                                Markers = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionMarkerArgs
                                    {
                                        Value = "string",
                                        DisplayType = "string",
                                        Label = "string",
                                        Time = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestStyleArgs
                                        {
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionXaxisArgs
                                {
                                    NumBuckets = 0,
                                },
                                Yaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            HostmapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                Groups = new[]
                                {
                                    "string",
                                },
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                NoGroupHosts = false,
                                NoMetricHosts = false,
                                NodeType = "string",
                                Notes = "string",
                                Request = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestArgs
                                {
                                    Fill = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                    Size = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                Scopes = new[]
                                {
                                    "string",
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionStyleArgs
                                {
                                    FillMax = "string",
                                    FillMin = "string",
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            Id = 0,
                            IframeDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionArgs
                            {
                                Url = "string",
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ImageDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionArgs
                            {
                                Url = "string",
                                Margin = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                HideIncompleteCostData = false,
                                HorizontalAlign = "string",
                                LiveSpan = "string",
                                Description = "string",
                                Sizing = "string",
                                HasBorder = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                HasBackground = false,
                                UrlDarkTheme = "string",
                                VerticalAlign = "string",
                            },
                            ListStreamDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionArgs
                            {
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestArgs
                                    {
                                        Columns = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestColumnArgs
                                            {
                                                Field = "string",
                                                Width = "string",
                                            },
                                        },
                                        Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryArgs
                                        {
                                            DataSource = "string",
                                            ClusteringPatternFieldPath = "string",
                                            EventSize = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            QueryString = "string",
                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQuerySortArgs
                                            {
                                                Column = "string",
                                                Order = "string",
                                            },
                                            Storage = "string",
                                        },
                                        ResponseFormat = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LegendSize = "string",
                                LiveSpan = "string",
                                ShowLegend = false,
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            LogStreamDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionArgs
                            {
                                Columns = new[]
                                {
                                    "string",
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                Indexes = new[]
                                {
                                    "string",
                                },
                                LiveSpan = "string",
                                MessageDisplay = "string",
                                Query = "string",
                                ShowDateColumn = false,
                                ShowMessageColumn = false,
                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionSortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ManageStatusDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionArgs
                            {
                                Query = "string",
                                HideIncompleteCostData = false,
                                ShowPriority = false,
                                ColorPreference = "string",
                                HideZeroCounts = false,
                                LiveSpan = "string",
                                Description = "string",
                                ShowLastTriggered = false,
                                DisplayFormat = "string",
                                Sort = "string",
                                SummaryType = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            NoteDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs
                            {
                                Content = "string",
                                TextAlign = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                FontSize = "string",
                                HasPadding = false,
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Description = "string",
                                TickEdge = "string",
                                ShowTick = false,
                                TickPos = "string",
                                BackgroundColor = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                VerticalAlign = "string",
                            },
                            QueryTableDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HasSearchBar = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        Alias = "string",
                                        CellDisplayModes = new[]
                                        {
                                            "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Limit = 0,
                                        Order = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        TextFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatArgs
                                            {
                                                TextFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                                    {
                                                        Match = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                                        {
                                                            Type = "string",
                                                            Value = "string",
                                                        },
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        Palette = "string",
                                                        Replace = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                                        {
                                                            Type = "string",
                                                            With = "string",
                                                            Substring = "string",
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            QueryValueDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionArgs
                            {
                                Autoscale = false,
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                CustomUnit = "string",
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Precision = 0,
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                TextAlign = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                TimeseriesBackground = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                                {
                                    Type = "string",
                                    Yaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                    {
                                        IncludeZero = false,
                                        Label = "string",
                                        Max = "string",
                                        Min = "string",
                                        Scale = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            RunWorkflowDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionArgs
                            {
                                WorkflowId = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                Inputs = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionInputArgs
                                    {
                                        Name = "string",
                                        Value = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SankeyDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionArgs
                            {
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestArgs
                                    {
                                        NetworkRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestArgs
                                        {
                                            Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQueryArgs
                                            {
                                                DataSource = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                QueryString = "string",
                                                Compute = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                },
                                                Mode = "string",
                                                ShouldExcludeMissing = false,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQuerySortArgs
                                                {
                                                    Field = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        RumRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestRumRequestArgs
                                        {
                                            Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestRumRequestQueryArgs
                                            {
                                                DataSource = "string",
                                                Mode = "string",
                                                QueryString = "string",
                                                EntriesPerStep = 0,
                                                NumberOfSteps = 0,
                                                Source = "string",
                                                SubqueryId = "string",
                                                Target = "string",
                                            },
                                        },
                                    },
                                },
                                ShowOtherLinks = false,
                                SortNodes = false,
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ScatterplotDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionArgs
                            {
                                ColorByGroups = new[]
                                {
                                    "string",
                                },
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Request = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestArgs
                                {
                                    ScatterplotTables = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableArgs
                                        {
                                            Formulas = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                                {
                                                    Dimension = "string",
                                                    FormulaExpression = "string",
                                                    Alias = "string",
                                                },
                                            },
                                            Queries = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                                {
                                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        OperationName = "string",
                                                        ResourceName = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        IsUpstream = false,
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                    },
                                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        OperationName = "string",
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                        ResourceName = "string",
                                                    },
                                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                    },
                                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                    {
                                                        Computes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Interval = 0,
                                                                Metric = "string",
                                                            },
                                                        },
                                                        DataSource = "string",
                                                        Name = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Metric = "string",
                                                                    Order = "string",
                                                                },
                                                            },
                                                        },
                                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs
                                                        {
                                                            Fields = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                        Indexes = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                        {
                                                            Query = "string",
                                                        },
                                                        Storage = "string",
                                                    },
                                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                    {
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        DataSource = "string",
                                                        SemanticMode = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Metric = "string",
                                                        Name = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        IsNormalizedCpu = false,
                                                        Limit = 0,
                                                        Sort = "string",
                                                        TagFilters = new[]
                                                        {
                                                            "string",
                                                        },
                                                        TextFilter = "string",
                                                    },
                                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Measure = "string",
                                                        SloId = "string",
                                                        AdditionalQueryFilters = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupMode = "string",
                                                        Name = "string",
                                                        SloQueryType = "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                    X = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXArgs
                                    {
                                        Aggregator = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                    Y = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYArgs
                                    {
                                        Aggregator = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionXaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                Yaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionArgs
                            {
                                SloId = "string",
                                ViewType = "string",
                                ViewMode = "string",
                                TimeWindows = new[]
                                {
                                    "string",
                                },
                                HideIncompleteCostData = false,
                                ShowErrorBudget = false,
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                AdditionalQueryFilters = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                GlobalTimeTarget = "string",
                                Description = "string",
                            },
                            ServicemapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionArgs
                            {
                                Filters = new[]
                                {
                                    "string",
                                },
                                Service = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SloListDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionArgs
                            {
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestArgs
                                    {
                                        Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestQueryArgs
                                        {
                                            QueryString = "string",
                                            Limit = 0,
                                            Sorts = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestQuerySortArgs
                                                {
                                                    Column = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        RequestType = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SunburstDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                HideTotal = false,
                                LegendInline = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionLegendInlineArgs
                                {
                                    Type = "string",
                                    HidePercent = false,
                                    HideValue = false,
                                },
                                LegendTable = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionLegendTableArgs
                                {
                                    Type = "string",
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortArgs
                                        {
                                            Count = 0,
                                            OrderBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByArgs
                                                {
                                                    FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByFormulaSortArgs
                                                    {
                                                        Index = 0,
                                                        Order = "string",
                                                    },
                                                    GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByGroupSortArgs
                                                    {
                                                        Name = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestStyleArgs
                                        {
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TimeseriesDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                Events = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionEventArgs
                                    {
                                        Q = "string",
                                        TagsExecution = "string",
                                    },
                                },
                                HideIncompleteCostData = false,
                                LegendColumns = new[]
                                {
                                    "string",
                                },
                                LegendLayout = "string",
                                LegendSize = "string",
                                LiveSpan = "string",
                                Markers = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionMarkerArgs
                                    {
                                        Value = "string",
                                        DisplayType = "string",
                                        Label = "string",
                                        Time = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestArgs
                                    {
                                        DisplayType = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Metadatas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestMetadataArgs
                                            {
                                                Expression = "string",
                                                AliasName = "string",
                                            },
                                        },
                                        OnRightYaxis = false,
                                        ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestStyleArgs
                                        {
                                            HasValueLabels = false,
                                            LineType = "string",
                                            LineWidth = "string",
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                RightYaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRightYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                ShowLegend = false,
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Yaxis = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            ToplistDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestArgs
                                    {
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortArgs
                                        {
                                            Count = 0,
                                            OrderBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByArgs
                                                {
                                                    FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByFormulaSortArgs
                                                    {
                                                        Index = 0,
                                                        Order = "string",
                                                    },
                                                    GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByGroupSortArgs
                                                    {
                                                        Name = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestStyleArgs
                                        {
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleArgs
                                {
                                    Display = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleDisplayArgs
                                    {
                                        Flat = null,
                                        Stacked = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleDisplayStackedArgs
                                        {
                                            Legend = "string",
                                        },
                                    },
                                    Palette = "string",
                                    Scaling = "string",
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TopologyMapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionRequestArgs
                                    {
                                        RequestType = "string",
                                        Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionRequestQueryArgs
                                        {
                                            DataSource = "string",
                                            Filters = new[]
                                            {
                                                "string",
                                            },
                                            Service = "string",
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TraceServiceDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionArgs
                            {
                                Service = "string",
                                SpanName = "string",
                                Env = "string",
                                ShowErrors = false,
                                ShowLatency = false,
                                HideIncompleteCostData = false,
                                ShowBreakdown = false,
                                ShowDistribution = false,
                                Description = "string",
                                ShowHits = false,
                                LiveSpan = "string",
                                ShowResourceList = false,
                                SizeFormat = "string",
                                DisplayFormat = "string",
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TreemapDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            PerUnitName = "string",
                                                            UnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortArgs
                                        {
                                            Count = 0,
                                            OrderBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByArgs
                                                {
                                                    FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByFormulaSortArgs
                                                    {
                                                        Index = 0,
                                                        Order = "string",
                                                    },
                                                    GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByGroupSortArgs
                                                    {
                                                        Name = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestStyleArgs
                                        {
                                            OrderBy = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            WidgetLayout = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWidgetLayoutArgs
                            {
                                Height = 0,
                                Width = 0,
                                X = 0,
                                Y = 0,
                                IsColumnBreak = false,
                            },
                            WildcardDefinition = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Description = "string",
                                HideIncompleteCostData = false,
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestArgs
                                    {
                                        HistogramRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestArgs
                                        {
                                            HistogramQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryArgs
                                            {
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestStyleArgs
                                            {
                                                OrderBy = "string",
                                                Palette = "string",
                                            },
                                        },
                                        ListstreamRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestArgs
                                        {
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestColumnArgs
                                                {
                                                    Field = "string",
                                                    Width = "string",
                                                },
                                            },
                                            Query = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQueryArgs
                                            {
                                                DataSource = "string",
                                                ClusteringPatternFieldPath = "string",
                                                EventSize = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                QueryString = "string",
                                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQuerySortArgs
                                                {
                                                    Column = "string",
                                                    Order = "string",
                                                },
                                                Storage = "string",
                                            },
                                        },
                                        TimeseriesRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestArgs
                                        {
                                            DisplayType = "string",
                                            Formulas = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaArgs
                                                {
                                                    FormulaExpression = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaCellDisplayModeOptionsArgs
                                                    {
                                                        TrendType = "string",
                                                        YScale = "string",
                                                    },
                                                    ConditionalFormats = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaConditionalFormatArgs
                                                        {
                                                            Comparator = "string",
                                                            Palette = "string",
                                                            Value = 0,
                                                            CustomBgColor = "string",
                                                            CustomFgColor = "string",
                                                            HideValue = false,
                                                            ImageUrl = "string",
                                                            Metric = "string",
                                                            Timeframe = "string",
                                                        },
                                                    },
                                                    Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaLimitArgs
                                                    {
                                                        Count = 0,
                                                        Order = "string",
                                                    },
                                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatArgs
                                                    {
                                                        Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitArgs
                                                        {
                                                            Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCanonicalArgs
                                                            {
                                                                PerUnitName = "string",
                                                                UnitName = "string",
                                                            },
                                                            Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCustomArgs
                                                            {
                                                                Label = "string",
                                                            },
                                                        },
                                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitScaleArgs
                                                        {
                                                            UnitName = "string",
                                                        },
                                                    },
                                                    Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaStyleArgs
                                                    {
                                                        Palette = "string",
                                                        PaletteIndex = 0,
                                                    },
                                                },
                                            },
                                            Queries = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryArgs
                                                {
                                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryApmDependencyStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        OperationName = "string",
                                                        ResourceName = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        IsUpstream = false,
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                    },
                                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryApmResourceStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        OperationName = "string",
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                        ResourceName = "string",
                                                    },
                                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryCloudCostQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                    },
                                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryArgs
                                                    {
                                                        Computes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Interval = 0,
                                                                Metric = "string",
                                                            },
                                                        },
                                                        DataSource = "string",
                                                        Name = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupBySortArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Metric = "string",
                                                                    Order = "string",
                                                                },
                                                            },
                                                        },
                                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsArgs
                                                        {
                                                            Fields = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsSortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                        Indexes = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQuerySearchArgs
                                                        {
                                                            Query = "string",
                                                        },
                                                        Storage = "string",
                                                    },
                                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryMetricQueryArgs
                                                    {
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        DataSource = "string",
                                                        SemanticMode = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryProcessQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Metric = "string",
                                                        Name = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        IsNormalizedCpu = false,
                                                        Limit = 0,
                                                        Sort = "string",
                                                        TagFilters = new[]
                                                        {
                                                            "string",
                                                        },
                                                        TextFilter = "string",
                                                    },
                                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQuerySloQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Measure = "string",
                                                        SloId = "string",
                                                        AdditionalQueryFilters = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupMode = "string",
                                                        Name = "string",
                                                        SloQueryType = "string",
                                                    },
                                                },
                                            },
                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortArgs
                                            {
                                                Count = 0,
                                                OrderBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByArgs
                                                    {
                                                        FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByFormulaSortArgs
                                                        {
                                                            Index = 0,
                                                            Order = "string",
                                                        },
                                                        GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByGroupSortArgs
                                                        {
                                                            Name = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestStyleArgs
                                            {
                                                OrderBy = "string",
                                                Palette = "string",
                                            },
                                        },
                                        TreemapRequest = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestArgs
                                        {
                                            Formulas = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaArgs
                                                {
                                                    FormulaExpression = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaCellDisplayModeOptionsArgs
                                                    {
                                                        TrendType = "string",
                                                        YScale = "string",
                                                    },
                                                    ConditionalFormats = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaConditionalFormatArgs
                                                        {
                                                            Comparator = "string",
                                                            Palette = "string",
                                                            Value = 0,
                                                            CustomBgColor = "string",
                                                            CustomFgColor = "string",
                                                            HideValue = false,
                                                            ImageUrl = "string",
                                                            Metric = "string",
                                                            Timeframe = "string",
                                                        },
                                                    },
                                                    Limit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaLimitArgs
                                                    {
                                                        Count = 0,
                                                        Order = "string",
                                                    },
                                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatArgs
                                                    {
                                                        Unit = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitArgs
                                                        {
                                                            Canonical = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCanonicalArgs
                                                            {
                                                                PerUnitName = "string",
                                                                UnitName = "string",
                                                            },
                                                            Custom = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCustomArgs
                                                            {
                                                                Label = "string",
                                                            },
                                                        },
                                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitScaleArgs
                                                        {
                                                            UnitName = "string",
                                                        },
                                                    },
                                                    Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaStyleArgs
                                                    {
                                                        Palette = "string",
                                                        PaletteIndex = 0,
                                                    },
                                                },
                                            },
                                            Queries = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryArgs
                                                {
                                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryApmDependencyStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        OperationName = "string",
                                                        ResourceName = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        IsUpstream = false,
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                    },
                                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryApmResourceStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        OperationName = "string",
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                        ResourceName = "string",
                                                    },
                                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryCloudCostQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                    },
                                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryArgs
                                                    {
                                                        Computes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Interval = 0,
                                                                Metric = "string",
                                                            },
                                                        },
                                                        DataSource = "string",
                                                        Name = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupBySortArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Metric = "string",
                                                                    Order = "string",
                                                                },
                                                            },
                                                        },
                                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsArgs
                                                        {
                                                            Fields = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsSortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                        Indexes = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Search = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQuerySearchArgs
                                                        {
                                                            Query = "string",
                                                        },
                                                        Storage = "string",
                                                    },
                                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryMetricQueryArgs
                                                    {
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        DataSource = "string",
                                                        SemanticMode = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryProcessQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Metric = "string",
                                                        Name = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        IsNormalizedCpu = false,
                                                        Limit = 0,
                                                        Sort = "string",
                                                        TagFilters = new[]
                                                        {
                                                            "string",
                                                        },
                                                        TextFilter = "string",
                                                    },
                                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQuerySloQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Measure = "string",
                                                        SloId = "string",
                                                        AdditionalQueryFilters = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupMode = "string",
                                                        Name = "string",
                                                        SloQueryType = "string",
                                                    },
                                                },
                                            },
                                            Sort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortArgs
                                            {
                                                Count = 0,
                                                OrderBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByArgs
                                                    {
                                                        FormulaSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByFormulaSortArgs
                                                        {
                                                            Index = 0,
                                                            Order = "string",
                                                        },
                                                        GroupSort = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByGroupSortArgs
                                                        {
                                                            Name = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestStyleArgs
                                            {
                                                OrderBy = "string",
                                                Palette = "string",
                                            },
                                        },
                                    },
                                },
                                Specification = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionSpecificationArgs
                                {
                                    Contents = "string",
                                    Type = "string",
                                },
                                Time = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeArgs
                                {
                                    Fixed = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeFixedArgs
                                    {
                                        From = 0,
                                        To = 0,
                                    },
                                    Live = new Datadog.Inputs.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeLiveArgs
                                    {
                                        Unit = "string",
                                        Value = 0,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                        },
                    },
                },
                HeatmapDefinition = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    Events = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    HideIncompleteCostData = false,
                    LegendSize = "string",
                    LiveSpan = "string",
                    Markers = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionMarkerArgs
                        {
                            Value = "string",
                            DisplayType = "string",
                            Label = "string",
                            Time = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionRequestStyleArgs
                            {
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionXaxisArgs
                    {
                        NumBuckets = 0,
                    },
                    Yaxis = new Datadog.Inputs.DashboardV2WidgetHeatmapDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                HostmapDefinition = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    Groups = new[]
                    {
                        "string",
                    },
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    NoGroupHosts = false,
                    NoMetricHosts = false,
                    NodeType = "string",
                    Notes = "string",
                    Request = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestArgs
                    {
                        Fill = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestFillQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                        Size = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionRequestSizeQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    Scopes = new[]
                    {
                        "string",
                    },
                    Style = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionStyleArgs
                    {
                        FillMax = "string",
                        FillMin = "string",
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetHostmapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                Id = 0,
                IframeDefinition = new Datadog.Inputs.DashboardV2WidgetIframeDefinitionArgs
                {
                    Url = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetIframeDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetIframeDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetIframeDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ImageDefinition = new Datadog.Inputs.DashboardV2WidgetImageDefinitionArgs
                {
                    Url = "string",
                    Margin = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetImageDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetImageDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetImageDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    HideIncompleteCostData = false,
                    HorizontalAlign = "string",
                    LiveSpan = "string",
                    Description = "string",
                    Sizing = "string",
                    HasBorder = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    HasBackground = false,
                    UrlDarkTheme = "string",
                    VerticalAlign = "string",
                },
                ListStreamDefinition = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionArgs
                {
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionRequestArgs
                        {
                            Columns = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionRequestColumnArgs
                                {
                                    Field = "string",
                                    Width = "string",
                                },
                            },
                            Query = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionRequestQueryArgs
                            {
                                DataSource = "string",
                                ClusteringPatternFieldPath = "string",
                                EventSize = "string",
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionRequestQueryGroupByArgs
                                    {
                                        Facet = "string",
                                    },
                                },
                                Indexes = new[]
                                {
                                    "string",
                                },
                                QueryString = "string",
                                Sort = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionRequestQuerySortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Storage = "string",
                            },
                            ResponseFormat = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LegendSize = "string",
                    LiveSpan = "string",
                    ShowLegend = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetListStreamDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                LogStreamDefinition = new Datadog.Inputs.DashboardV2WidgetLogStreamDefinitionArgs
                {
                    Columns = new[]
                    {
                        "string",
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    Indexes = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    MessageDisplay = "string",
                    Query = "string",
                    ShowDateColumn = false,
                    ShowMessageColumn = false,
                    Sort = new Datadog.Inputs.DashboardV2WidgetLogStreamDefinitionSortArgs
                    {
                        Column = "string",
                        Order = "string",
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetLogStreamDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetLogStreamDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetLogStreamDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ManageStatusDefinition = new Datadog.Inputs.DashboardV2WidgetManageStatusDefinitionArgs
                {
                    Query = "string",
                    HideIncompleteCostData = false,
                    ShowPriority = false,
                    ColorPreference = "string",
                    HideZeroCounts = false,
                    LiveSpan = "string",
                    Description = "string",
                    ShowLastTriggered = false,
                    DisplayFormat = "string",
                    Sort = "string",
                    SummaryType = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetManageStatusDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetManageStatusDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetManageStatusDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                NoteDefinition = new Datadog.Inputs.DashboardV2WidgetNoteDefinitionArgs
                {
                    Content = "string",
                    TextAlign = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetNoteDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetNoteDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetNoteDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    FontSize = "string",
                    HasPadding = false,
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Description = "string",
                    TickEdge = "string",
                    ShowTick = false,
                    TickPos = "string",
                    BackgroundColor = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    VerticalAlign = "string",
                },
                PowerpackDefinition = new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionArgs
                {
                    PowerpackId = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    ShowTitle = false,
                    TemplateVariables = new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTemplateVariablesArgs
                    {
                        ControlledByPowerpacks = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs
                            {
                                Name = "string",
                                Values = new[]
                                {
                                    "string",
                                },
                                Prefix = "string",
                            },
                        },
                        ControlledExternallies = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs
                            {
                                Name = "string",
                                Values = new[]
                                {
                                    "string",
                                },
                                Prefix = "string",
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetPowerpackDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                QueryTableDefinition = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HasSearchBar = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            Alias = "string",
                            CellDisplayModes = new[]
                            {
                                "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Limit = 0,
                            Order = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            TextFormats = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestTextFormatArgs
                                {
                                    TextFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                        {
                                            Match = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                            {
                                                Type = "string",
                                                Value = "string",
                                            },
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            Palette = "string",
                                            Replace = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                            {
                                                Type = "string",
                                                With = "string",
                                                Substring = "string",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetQueryTableDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                QueryValueDefinition = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionArgs
                {
                    Autoscale = false,
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    CustomUnit = "string",
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Precision = 0,
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    TextAlign = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    TimeseriesBackground = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionTimeseriesBackgroundArgs
                    {
                        Type = "string",
                        Yaxis = new Datadog.Inputs.DashboardV2WidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                        {
                            IncludeZero = false,
                            Label = "string",
                            Max = "string",
                            Min = "string",
                            Scale = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                RunWorkflowDefinition = new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionArgs
                {
                    WorkflowId = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    Inputs = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionInputArgs
                        {
                            Name = "string",
                            Value = "string",
                        },
                    },
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetRunWorkflowDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SankeyDefinition = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionArgs
                {
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestArgs
                        {
                            NetworkRequest = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestArgs
                            {
                                Query = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQueryArgs
                                {
                                    DataSource = "string",
                                    GroupBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    QueryString = "string",
                                    Compute = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQueryComputeArgs
                                    {
                                        Aggregation = "string",
                                        Metric = "string",
                                    },
                                    Mode = "string",
                                    ShouldExcludeMissing = false,
                                    Sort = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQuerySortArgs
                                    {
                                        Field = "string",
                                        Order = "string",
                                    },
                                },
                            },
                            RumRequest = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestRumRequestArgs
                            {
                                Query = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionRequestRumRequestQueryArgs
                                {
                                    DataSource = "string",
                                    Mode = "string",
                                    QueryString = "string",
                                    EntriesPerStep = 0,
                                    NumberOfSteps = 0,
                                    Source = "string",
                                    SubqueryId = "string",
                                    Target = "string",
                                },
                            },
                        },
                    },
                    ShowOtherLinks = false,
                    SortNodes = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetSankeyDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ScatterplotDefinition = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionArgs
                {
                    ColorByGroups = new[]
                    {
                        "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Request = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestArgs
                    {
                        ScatterplotTables = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                    {
                                        Dimension = "string",
                                        FormulaExpression = "string",
                                        Alias = "string",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                    {
                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            OperationName = "string",
                                            ResourceName = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            IsUpstream = false,
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                        },
                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                "string",
                                            },
                                            OperationName = "string",
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                            ResourceName = "string",
                                        },
                                        CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                        {
                                            DataSource = "string",
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                        },
                                        EventQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                        {
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Interval = 0,
                                                    Metric = "string",
                                                },
                                            },
                                            DataSource = "string",
                                            Name = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                            GroupByFields = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs
                                            {
                                                Fields = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            Search = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                            {
                                                Query = "string",
                                            },
                                            Storage = "string",
                                        },
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                        {
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            DataSource = "string",
                                            SemanticMode = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                        {
                                            DataSource = "string",
                                            Metric = "string",
                                            Name = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            IsNormalizedCpu = false,
                                            Limit = 0,
                                            Sort = "string",
                                            TagFilters = new[]
                                            {
                                                "string",
                                            },
                                            TextFilter = "string",
                                        },
                                        SloQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                        {
                                            DataSource = "string",
                                            Measure = "string",
                                            SloId = "string",
                                            AdditionalQueryFilters = "string",
                                            CrossOrgUuids = "string",
                                            GroupMode = "string",
                                            Name = "string",
                                            SloQueryType = "string",
                                        },
                                    },
                                },
                            },
                        },
                        X = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXArgs
                        {
                            Aggregator = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestXQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                        Y = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYArgs
                        {
                            Aggregator = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionRequestYQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionXaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    Yaxis = new Datadog.Inputs.DashboardV2WidgetScatterplotDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardV2WidgetServiceLevelObjectiveDefinitionArgs
                {
                    SloId = "string",
                    ViewType = "string",
                    ViewMode = "string",
                    TimeWindows = new[]
                    {
                        "string",
                    },
                    HideIncompleteCostData = false,
                    ShowErrorBudget = false,
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    AdditionalQueryFilters = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    GlobalTimeTarget = "string",
                    Description = "string",
                },
                ServicemapDefinition = new Datadog.Inputs.DashboardV2WidgetServicemapDefinitionArgs
                {
                    Filters = new[]
                    {
                        "string",
                    },
                    Service = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetServicemapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetServicemapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetServicemapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetServicemapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SloListDefinition = new Datadog.Inputs.DashboardV2WidgetSloListDefinitionArgs
                {
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetSloListDefinitionRequestArgs
                        {
                            Query = new Datadog.Inputs.DashboardV2WidgetSloListDefinitionRequestQueryArgs
                            {
                                QueryString = "string",
                                Limit = 0,
                                Sorts = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetSloListDefinitionRequestQuerySortArgs
                                    {
                                        Column = "string",
                                        Order = "string",
                                    },
                                },
                            },
                            RequestType = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetSloListDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetSloListDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetSloListDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SplitGraphDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionArgs
                {
                    Size = "string",
                    SplitConfig = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigArgs
                    {
                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigSortArgs
                        {
                            Order = "string",
                            Compute = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigSortComputeArgs
                            {
                                Metric = "string",
                                Aggregation = "string",
                            },
                        },
                        SplitDimensions = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigSplitDimensionArgs
                            {
                                OneGraphPer = "string",
                            },
                        },
                        Limit = 0,
                        StaticSplits = new[]
                        {
                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitArgs
                            {
                                SplitVectors = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArgs
                                    {
                                        TagKey = "string",
                                        TagValues = new[]
                                        {
                                            "string",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    Description = "string",
                    HasUniformYAxes = false,
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    SourceWidgetDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionArgs
                    {
                        ChangeDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestArgs
                                {
                                    ChangeType = "string",
                                    CompareTo = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    IncreaseGood = false,
                                    OrderBy = "string",
                                    OrderDir = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    ShowPresent = false,
                                },
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        GeomapDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestArgs
                                {
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionStyleArgs
                            {
                                Palette = "string",
                                PaletteFlip = false,
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                            View = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionViewArgs
                            {
                                Focus = "string",
                            },
                        },
                        QueryTableDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HasSearchBar = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestArgs
                                {
                                    Aggregator = "string",
                                    Alias = "string",
                                    CellDisplayModes = new[]
                                    {
                                        "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Limit = 0,
                                    Order = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    TextFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatArgs
                                        {
                                            TextFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatArgs
                                                {
                                                    Match = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                                    {
                                                        Type = "string",
                                                        Value = "string",
                                                    },
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    Palette = "string",
                                                    Replace = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                                    {
                                                        Type = "string",
                                                        With = "string",
                                                        Substring = "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        QueryValueDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionArgs
                        {
                            Autoscale = false,
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            CustomUnit = "string",
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Precision = 0,
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestArgs
                                {
                                    Aggregator = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                },
                            },
                            TextAlign = "string",
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            TimeseriesBackground = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeseriesBackgroundArgs
                            {
                                Type = "string",
                                Yaxis = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        ScatterplotDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionArgs
                        {
                            ColorByGroups = new[]
                            {
                                "string",
                            },
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Request = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestArgs
                            {
                                ScatterplotTables = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                            {
                                                Dimension = "string",
                                                FormulaExpression = "string",
                                                Alias = "string",
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs
                                                    {
                                                        Fields = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                    SemanticMode = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                X = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXArgs
                                {
                                    Aggregator = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                },
                                Y = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYArgs
                                {
                                    Aggregator = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                },
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                            Xaxis = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionXaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                            Yaxis = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                        },
                        SunburstDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            HideTotal = false,
                            LegendInline = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionLegendInlineArgs
                            {
                                Type = "string",
                                HidePercent = false,
                                HideValue = false,
                            },
                            LegendTable = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionLegendTableArgs
                            {
                                Type = "string",
                            },
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestArgs
                                {
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestSortArgs
                                    {
                                        Count = 0,
                                        OrderBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestSortOrderByArgs
                                            {
                                                FormulaSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestSortOrderByFormulaSortArgs
                                                {
                                                    Index = 0,
                                                    Order = "string",
                                                },
                                                GroupSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestSortOrderByGroupSortArgs
                                                {
                                                    Name = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionRequestStyleArgs
                                    {
                                        OrderBy = "string",
                                        Palette = "string",
                                    },
                                },
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionSunburstDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        TimeseriesDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            Events = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionEventArgs
                                {
                                    Q = "string",
                                    TagsExecution = "string",
                                },
                            },
                            HideIncompleteCostData = false,
                            LegendColumns = new[]
                            {
                                "string",
                            },
                            LegendLayout = "string",
                            LegendSize = "string",
                            LiveSpan = "string",
                            Markers = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionMarkerArgs
                                {
                                    Value = "string",
                                    DisplayType = "string",
                                    Label = "string",
                                    Time = "string",
                                },
                            },
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestArgs
                                {
                                    DisplayType = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Metadatas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestMetadataArgs
                                        {
                                            Expression = "string",
                                            AliasName = "string",
                                        },
                                    },
                                    OnRightYaxis = false,
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRequestStyleArgs
                                    {
                                        HasValueLabels = false,
                                        LineType = "string",
                                        LineWidth = "string",
                                        OrderBy = "string",
                                        Palette = "string",
                                    },
                                },
                            },
                            RightYaxis = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionRightYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                            ShowLegend = false,
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                            Yaxis = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTimeseriesDefinitionYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                        },
                        ToplistDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestArgs
                                {
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestSortArgs
                                    {
                                        Count = 0,
                                        OrderBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestSortOrderByArgs
                                            {
                                                FormulaSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestSortOrderByFormulaSortArgs
                                                {
                                                    Index = 0,
                                                    Order = "string",
                                                },
                                                GroupSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestSortOrderByGroupSortArgs
                                                {
                                                    Name = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionRequestStyleArgs
                                    {
                                        OrderBy = "string",
                                        Palette = "string",
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionStyleArgs
                            {
                                Display = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionStyleDisplayArgs
                                {
                                    Flat = null,
                                    Stacked = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionStyleDisplayStackedArgs
                                    {
                                        Legend = "string",
                                    },
                                },
                                Palette = "string",
                                Scaling = "string",
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionToplistDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        TreemapDefinition = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Description = "string",
                            HideIncompleteCostData = false,
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestArgs
                                {
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        PerUnitName = "string",
                                                        UnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    "string",
                                                },
                                                OperationName = "string",
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                                ResourceName = "string",
                                            },
                                            CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                GroupByFields = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                                {
                                                    Fields = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                                SemanticMode = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQueryProcessQueryArgs
                                            {
                                                DataSource = "string",
                                                Metric = "string",
                                                Name = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                IsNormalizedCpu = false,
                                                Limit = 0,
                                                Sort = "string",
                                                TagFilters = new[]
                                                {
                                                    "string",
                                                },
                                                TextFilter = "string",
                                            },
                                            SloQuery = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    Sort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestSortArgs
                                    {
                                        Count = 0,
                                        OrderBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestSortOrderByArgs
                                            {
                                                FormulaSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestSortOrderByFormulaSortArgs
                                                {
                                                    Index = 0,
                                                    Order = "string",
                                                },
                                                GroupSort = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestSortOrderByGroupSortArgs
                                                {
                                                    Name = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionRequestStyleArgs
                                    {
                                        OrderBy = "string",
                                        Palette = "string",
                                    },
                                },
                            },
                            Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionTimeArgs
                            {
                                Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionTimeFixedArgs
                                {
                                    From = 0,
                                    To = 0,
                                },
                                Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionTreemapDefinitionTimeLiveArgs
                                {
                                    Unit = "string",
                                    Value = 0,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetSplitGraphDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SunburstDefinition = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    HideTotal = false,
                    LegendInline = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionLegendInlineArgs
                    {
                        Type = "string",
                        HidePercent = false,
                        HideValue = false,
                    },
                    LegendTable = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionLegendTableArgs
                    {
                        Type = "string",
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            Sort = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestSortArgs
                            {
                                Count = 0,
                                OrderBies = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestSortOrderByArgs
                                    {
                                        FormulaSort = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestSortOrderByFormulaSortArgs
                                        {
                                            Index = 0,
                                            Order = "string",
                                        },
                                        GroupSort = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestSortOrderByGroupSortArgs
                                        {
                                            Name = "string",
                                            Order = "string",
                                        },
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionRequestStyleArgs
                            {
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetSunburstDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TimeseriesDefinition = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    Events = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    HideIncompleteCostData = false,
                    LegendColumns = new[]
                    {
                        "string",
                    },
                    LegendLayout = "string",
                    LegendSize = "string",
                    LiveSpan = "string",
                    Markers = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionMarkerArgs
                        {
                            Value = "string",
                            DisplayType = "string",
                            Label = "string",
                            Time = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestArgs
                        {
                            DisplayType = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Metadatas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestMetadataArgs
                                {
                                    Expression = "string",
                                    AliasName = "string",
                                },
                            },
                            OnRightYaxis = false,
                            ProcessQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRequestStyleArgs
                            {
                                HasValueLabels = false,
                                LineType = "string",
                                LineWidth = "string",
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    RightYaxis = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionRightYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    ShowLegend = false,
                    Time = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Yaxis = new Datadog.Inputs.DashboardV2WidgetTimeseriesDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ToplistDefinition = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetToplistDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestArgs
                        {
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            Sort = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestSortArgs
                            {
                                Count = 0,
                                OrderBies = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestSortOrderByArgs
                                    {
                                        FormulaSort = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestSortOrderByFormulaSortArgs
                                        {
                                            Index = 0,
                                            Order = "string",
                                        },
                                        GroupSort = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestSortOrderByGroupSortArgs
                                        {
                                            Name = "string",
                                            Order = "string",
                                        },
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionRequestStyleArgs
                            {
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    Style = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionStyleArgs
                    {
                        Display = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionStyleDisplayArgs
                        {
                            Flat = null,
                            Stacked = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionStyleDisplayStackedArgs
                            {
                                Legend = "string",
                            },
                        },
                        Palette = "string",
                        Scaling = "string",
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetToplistDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TopologyMapDefinition = new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionRequestArgs
                        {
                            RequestType = "string",
                            Query = new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionRequestQueryArgs
                            {
                                DataSource = "string",
                                Filters = new[]
                                {
                                    "string",
                                },
                                Service = "string",
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetTopologyMapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TraceServiceDefinition = new Datadog.Inputs.DashboardV2WidgetTraceServiceDefinitionArgs
                {
                    Service = "string",
                    SpanName = "string",
                    Env = "string",
                    ShowErrors = false,
                    ShowLatency = false,
                    HideIncompleteCostData = false,
                    ShowBreakdown = false,
                    ShowDistribution = false,
                    Description = "string",
                    ShowHits = false,
                    LiveSpan = "string",
                    ShowResourceList = false,
                    SizeFormat = "string",
                    DisplayFormat = "string",
                    Time = new Datadog.Inputs.DashboardV2WidgetTraceServiceDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetTraceServiceDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetTraceServiceDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TreemapDefinition = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                PerUnitName = "string",
                                                UnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            Sort = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestSortArgs
                            {
                                Count = 0,
                                OrderBies = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestSortOrderByArgs
                                    {
                                        FormulaSort = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestSortOrderByFormulaSortArgs
                                        {
                                            Index = 0,
                                            Order = "string",
                                        },
                                        GroupSort = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestSortOrderByGroupSortArgs
                                        {
                                            Name = "string",
                                            Order = "string",
                                        },
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionRequestStyleArgs
                            {
                                OrderBy = "string",
                                Palette = "string",
                            },
                        },
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetTreemapDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                WidgetLayout = new Datadog.Inputs.DashboardV2WidgetWidgetLayoutArgs
                {
                    Height = 0,
                    Width = 0,
                    X = 0,
                    Y = 0,
                    IsColumnBreak = false,
                },
                WildcardDefinition = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Description = "string",
                    HideIncompleteCostData = false,
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestArgs
                        {
                            HistogramRequest = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestArgs
                            {
                                HistogramQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryArgs
                                {
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        GroupByFields = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsArgs
                                        {
                                            Fields = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsSortArgs
                                            {
                                                Aggregation = "string",
                                                Metric = "string",
                                                Order = "string",
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestHistogramQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                        SemanticMode = "string",
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestHistogramRequestStyleArgs
                                {
                                    OrderBy = "string",
                                    Palette = "string",
                                },
                            },
                            ListstreamRequest = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestListstreamRequestArgs
                            {
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestListstreamRequestColumnArgs
                                    {
                                        Field = "string",
                                        Width = "string",
                                    },
                                },
                                Query = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestListstreamRequestQueryArgs
                                {
                                    DataSource = "string",
                                    ClusteringPatternFieldPath = "string",
                                    EventSize = "string",
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestListstreamRequestQueryGroupByArgs
                                        {
                                            Facet = "string",
                                        },
                                    },
                                    Indexes = new[]
                                    {
                                        "string",
                                    },
                                    QueryString = "string",
                                    Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestListstreamRequestQuerySortArgs
                                    {
                                        Column = "string",
                                        Order = "string",
                                    },
                                    Storage = "string",
                                },
                            },
                            TimeseriesRequest = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestArgs
                            {
                                DisplayType = "string",
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaArgs
                                    {
                                        FormulaExpression = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaCellDisplayModeOptionsArgs
                                        {
                                            TrendType = "string",
                                            YScale = "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Limit = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaLimitArgs
                                        {
                                            Count = 0,
                                            Order = "string",
                                        },
                                        NumberFormat = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatArgs
                                        {
                                            Unit = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitArgs
                                            {
                                                Canonical = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCanonicalArgs
                                                {
                                                    PerUnitName = "string",
                                                    UnitName = "string",
                                                },
                                                Custom = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCustomArgs
                                                {
                                                    Label = "string",
                                                },
                                            },
                                            UnitScale = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitScaleArgs
                                            {
                                                UnitName = "string",
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestFormulaStyleArgs
                                        {
                                            Palette = "string",
                                            PaletteIndex = 0,
                                        },
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryArgs
                                    {
                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryApmDependencyStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            OperationName = "string",
                                            ResourceName = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            IsUpstream = false,
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                        },
                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryApmResourceStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                "string",
                                            },
                                            OperationName = "string",
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                            ResourceName = "string",
                                        },
                                        CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryCloudCostQueryArgs
                                        {
                                            DataSource = "string",
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                        },
                                        EventQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryArgs
                                        {
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Interval = 0,
                                                    Metric = "string",
                                                },
                                            },
                                            DataSource = "string",
                                            Name = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupBySortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                            GroupByFields = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsArgs
                                            {
                                                Fields = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsSortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            Search = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQuerySearchArgs
                                            {
                                                Query = "string",
                                            },
                                            Storage = "string",
                                        },
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryMetricQueryArgs
                                        {
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            DataSource = "string",
                                            SemanticMode = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQueryProcessQueryArgs
                                        {
                                            DataSource = "string",
                                            Metric = "string",
                                            Name = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            IsNormalizedCpu = false,
                                            Limit = 0,
                                            Sort = "string",
                                            TagFilters = new[]
                                            {
                                                "string",
                                            },
                                            TextFilter = "string",
                                        },
                                        SloQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestQuerySloQueryArgs
                                        {
                                            DataSource = "string",
                                            Measure = "string",
                                            SloId = "string",
                                            AdditionalQueryFilters = "string",
                                            CrossOrgUuids = "string",
                                            GroupMode = "string",
                                            Name = "string",
                                            SloQueryType = "string",
                                        },
                                    },
                                },
                                Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestSortArgs
                                {
                                    Count = 0,
                                    OrderBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByArgs
                                        {
                                            FormulaSort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByFormulaSortArgs
                                            {
                                                Index = 0,
                                                Order = "string",
                                            },
                                            GroupSort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByGroupSortArgs
                                            {
                                                Name = "string",
                                                Order = "string",
                                            },
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTimeseriesRequestStyleArgs
                                {
                                    OrderBy = "string",
                                    Palette = "string",
                                },
                            },
                            TreemapRequest = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaArgs
                                    {
                                        FormulaExpression = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        CellDisplayModeOptions = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaCellDisplayModeOptionsArgs
                                        {
                                            TrendType = "string",
                                            YScale = "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Limit = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaLimitArgs
                                        {
                                            Count = 0,
                                            Order = "string",
                                        },
                                        NumberFormat = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatArgs
                                        {
                                            Unit = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitArgs
                                            {
                                                Canonical = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCanonicalArgs
                                                {
                                                    PerUnitName = "string",
                                                    UnitName = "string",
                                                },
                                                Custom = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCustomArgs
                                                {
                                                    Label = "string",
                                                },
                                            },
                                            UnitScale = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitScaleArgs
                                            {
                                                UnitName = "string",
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestFormulaStyleArgs
                                        {
                                            Palette = "string",
                                            PaletteIndex = 0,
                                        },
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryArgs
                                    {
                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryApmDependencyStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            OperationName = "string",
                                            ResourceName = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            IsUpstream = false,
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                        },
                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryApmResourceStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                "string",
                                            },
                                            OperationName = "string",
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                            ResourceName = "string",
                                        },
                                        CloudCostQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryCloudCostQueryArgs
                                        {
                                            DataSource = "string",
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                        },
                                        EventQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryArgs
                                        {
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Interval = 0,
                                                    Metric = "string",
                                                },
                                            },
                                            DataSource = "string",
                                            Name = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupBySortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                            GroupByFields = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsArgs
                                            {
                                                Fields = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsSortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            Search = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryEventQuerySearchArgs
                                            {
                                                Query = "string",
                                            },
                                            Storage = "string",
                                        },
                                        MetricQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryMetricQueryArgs
                                        {
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            DataSource = "string",
                                            SemanticMode = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQueryProcessQueryArgs
                                        {
                                            DataSource = "string",
                                            Metric = "string",
                                            Name = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            IsNormalizedCpu = false,
                                            Limit = 0,
                                            Sort = "string",
                                            TagFilters = new[]
                                            {
                                                "string",
                                            },
                                            TextFilter = "string",
                                        },
                                        SloQuery = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestQuerySloQueryArgs
                                        {
                                            DataSource = "string",
                                            Measure = "string",
                                            SloId = "string",
                                            AdditionalQueryFilters = "string",
                                            CrossOrgUuids = "string",
                                            GroupMode = "string",
                                            Name = "string",
                                            SloQueryType = "string",
                                        },
                                    },
                                },
                                Sort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestSortArgs
                                {
                                    Count = 0,
                                    OrderBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestSortOrderByArgs
                                        {
                                            FormulaSort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestSortOrderByFormulaSortArgs
                                            {
                                                Index = 0,
                                                Order = "string",
                                            },
                                            GroupSort = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestSortOrderByGroupSortArgs
                                            {
                                                Name = "string",
                                                Order = "string",
                                            },
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionRequestTreemapRequestStyleArgs
                                {
                                    OrderBy = "string",
                                    Palette = "string",
                                },
                            },
                        },
                    },
                    Specification = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionSpecificationArgs
                    {
                        Contents = "string",
                        Type = "string",
                    },
                    Time = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionTimeArgs
                    {
                        Fixed = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionTimeFixedArgs
                        {
                            From = 0,
                            To = 0,
                        },
                        Live = new Datadog.Inputs.DashboardV2WidgetWildcardDefinitionTimeLiveArgs
                        {
                            Unit = "string",
                            Value = 0,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
            },
        },
    });
    
    example, err := datadog.NewDashboardV2(ctx, "dashboardV2Resource", &datadog.DashboardV2Args{
    	LayoutType:  pulumi.String("string"),
    	Title:       pulumi.String("string"),
    	ReflowType:  pulumi.String("string"),
    	Description: pulumi.String("string"),
    	NotifyLists: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	DashboardLists: pulumi.IntArray{
    		pulumi.Int(0),
    	},
    	RestrictedRoles: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Tabs: datadog.DashboardV2TabArray{
    		&datadog.DashboardV2TabArgs{
    			Name: pulumi.String("string"),
    			WidgetIds: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Id: pulumi.String("string"),
    		},
    	},
    	Tags: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	TemplateVariablePresets: datadog.DashboardV2TemplateVariablePresetArray{
    		&datadog.DashboardV2TemplateVariablePresetArgs{
    			Name: pulumi.String("string"),
    			TemplateVariables: datadog.DashboardV2TemplateVariablePresetTemplateVariableArray{
    				&datadog.DashboardV2TemplateVariablePresetTemplateVariableArgs{
    					Name: pulumi.String("string"),
    					Values: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    		},
    	},
    	TemplateVariables: datadog.DashboardV2TemplateVariableArray{
    		&datadog.DashboardV2TemplateVariableArgs{
    			Name: pulumi.String("string"),
    			AvailableValues: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Defaults: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Prefix: pulumi.String("string"),
    			Type:   pulumi.String("string"),
    		},
    	},
    	DashboardListsRemoveds: pulumi.IntArray{
    		pulumi.Int(0),
    	},
    	Url: pulumi.String("string"),
    	Widgets: datadog.DashboardV2WidgetArray{
    		&datadog.DashboardV2WidgetArgs{
    			AlertGraphDefinition: &datadog.DashboardV2WidgetAlertGraphDefinitionArgs{
    				AlertId:                pulumi.String("string"),
    				VizType:                pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetAlertGraphDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetAlertGraphDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetAlertGraphDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			AlertValueDefinition: &datadog.DashboardV2WidgetAlertValueDefinitionArgs{
    				AlertId:                pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Precision:              pulumi.Int(0),
    				TextAlign:              pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetAlertValueDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetAlertValueDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetAlertValueDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Unit:       pulumi.String("string"),
    			},
    			BarChartDefinition: &datadog.DashboardV2WidgetBarChartDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetBarChartDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetBarChartDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Request: &datadog.DashboardV2WidgetBarChartDefinitionRequestArgs{
    					ConditionalFormats: datadog.DashboardV2WidgetBarChartDefinitionRequestConditionalFormatArray{
    						&datadog.DashboardV2WidgetBarChartDefinitionRequestConditionalFormatArgs{
    							Comparator:    pulumi.String("string"),
    							Palette:       pulumi.String("string"),
    							Value:         pulumi.Float64(0),
    							CustomBgColor: pulumi.String("string"),
    							CustomFgColor: pulumi.String("string"),
    							HideValue:     pulumi.Bool(false),
    							ImageUrl:      pulumi.String("string"),
    							Metric:        pulumi.String("string"),
    							Timeframe:     pulumi.String("string"),
    						},
    					},
    					Formulas: datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaArray{
    						&datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaArgs{
    							FormulaExpression: pulumi.String("string"),
    							Alias:             pulumi.String("string"),
    							CellDisplayMode:   pulumi.String("string"),
    							CellDisplayModeOptions: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    								TrendType: pulumi.String("string"),
    								YScale:    pulumi.String("string"),
    							},
    							ConditionalFormats: datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaConditionalFormatArray{
    								&datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaConditionalFormatArgs{
    									Comparator:    pulumi.String("string"),
    									Palette:       pulumi.String("string"),
    									Value:         pulumi.Float64(0),
    									CustomBgColor: pulumi.String("string"),
    									CustomFgColor: pulumi.String("string"),
    									HideValue:     pulumi.Bool(false),
    									ImageUrl:      pulumi.String("string"),
    									Metric:        pulumi.String("string"),
    									Timeframe:     pulumi.String("string"),
    								},
    							},
    							Limit: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaLimitArgs{
    								Count: pulumi.Int(0),
    								Order: pulumi.String("string"),
    							},
    							NumberFormat: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatArgs{
    								Unit: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitArgs{
    									Canonical: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    										PerUnitName: pulumi.String("string"),
    										UnitName:    pulumi.String("string"),
    									},
    									Custom: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    										Label: pulumi.String("string"),
    									},
    								},
    								UnitScale: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    									UnitName: pulumi.String("string"),
    								},
    							},
    							Style: &datadog.DashboardV2WidgetBarChartDefinitionRequestFormulaStyleArgs{
    								Palette:      pulumi.String("string"),
    								PaletteIndex: pulumi.Int(0),
    							},
    						},
    					},
    					Queries: datadog.DashboardV2WidgetBarChartDefinitionRequestQueryArray{
    						&datadog.DashboardV2WidgetBarChartDefinitionRequestQueryArgs{
    							ApmDependencyStatsQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryApmDependencyStatsQueryArgs{
    								DataSource:      pulumi.String("string"),
    								Env:             pulumi.String("string"),
    								Name:            pulumi.String("string"),
    								OperationName:   pulumi.String("string"),
    								ResourceName:    pulumi.String("string"),
    								Service:         pulumi.String("string"),
    								Stat:            pulumi.String("string"),
    								CrossOrgUuids:   pulumi.String("string"),
    								IsUpstream:      pulumi.Bool(false),
    								PrimaryTagName:  pulumi.String("string"),
    								PrimaryTagValue: pulumi.String("string"),
    							},
    							ApmResourceStatsQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryApmResourceStatsQueryArgs{
    								DataSource:    pulumi.String("string"),
    								Env:           pulumi.String("string"),
    								Name:          pulumi.String("string"),
    								Service:       pulumi.String("string"),
    								Stat:          pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								GroupBies: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								OperationName:   pulumi.String("string"),
    								PrimaryTagName:  pulumi.String("string"),
    								PrimaryTagValue: pulumi.String("string"),
    								ResourceName:    pulumi.String("string"),
    							},
    							CloudCostQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryCloudCostQueryArgs{
    								DataSource:    pulumi.String("string"),
    								Name:          pulumi.String("string"),
    								Query:         pulumi.String("string"),
    								Aggregator:    pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    							},
    							EventQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryArgs{
    								Computes: datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryComputeArray{
    									&datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryComputeArgs{
    										Aggregation: pulumi.String("string"),
    										Interval:    pulumi.Int(0),
    										Metric:      pulumi.String("string"),
    									},
    								},
    								DataSource:    pulumi.String("string"),
    								Name:          pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								GroupBies: datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByArray{
    									&datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByArgs{
    										Facet: pulumi.String("string"),
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupBySortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    								},
    								GroupByFields: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    									Fields: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Limit: pulumi.Int(0),
    									Sort: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    										Aggregation: pulumi.String("string"),
    										Metric:      pulumi.String("string"),
    										Order:       pulumi.String("string"),
    									},
    								},
    								Indexes: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								Search: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryEventQuerySearchArgs{
    									Query: pulumi.String("string"),
    								},
    								Storage: pulumi.String("string"),
    							},
    							MetricQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryMetricQueryArgs{
    								Name:          pulumi.String("string"),
    								Query:         pulumi.String("string"),
    								Aggregator:    pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								DataSource:    pulumi.String("string"),
    								SemanticMode:  pulumi.String("string"),
    							},
    							ProcessQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQueryProcessQueryArgs{
    								DataSource:      pulumi.String("string"),
    								Metric:          pulumi.String("string"),
    								Name:            pulumi.String("string"),
    								Aggregator:      pulumi.String("string"),
    								CrossOrgUuids:   pulumi.String("string"),
    								IsNormalizedCpu: pulumi.Bool(false),
    								Limit:           pulumi.Int(0),
    								Sort:            pulumi.String("string"),
    								TagFilters: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								TextFilter: pulumi.String("string"),
    							},
    							SloQuery: &datadog.DashboardV2WidgetBarChartDefinitionRequestQuerySloQueryArgs{
    								DataSource:             pulumi.String("string"),
    								Measure:                pulumi.String("string"),
    								SloId:                  pulumi.String("string"),
    								AdditionalQueryFilters: pulumi.String("string"),
    								CrossOrgUuids:          pulumi.String("string"),
    								GroupMode:              pulumi.String("string"),
    								Name:                   pulumi.String("string"),
    								SloQueryType:           pulumi.String("string"),
    							},
    						},
    					},
    					Sort: &datadog.DashboardV2WidgetBarChartDefinitionRequestSortArgs{
    						Count: pulumi.Int(0),
    						OrderBies: datadog.DashboardV2WidgetBarChartDefinitionRequestSortOrderByArray{
    							&datadog.DashboardV2WidgetBarChartDefinitionRequestSortOrderByArgs{
    								FormulaSort: &datadog.DashboardV2WidgetBarChartDefinitionRequestSortOrderByFormulaSortArgs{
    									Index: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								GroupSort: &datadog.DashboardV2WidgetBarChartDefinitionRequestSortOrderByGroupSortArgs{
    									Name:  pulumi.String("string"),
    									Order: pulumi.String("string"),
    								},
    							},
    						},
    					},
    					Style: &datadog.DashboardV2WidgetBarChartDefinitionRequestStyleArgs{
    						OrderBy: pulumi.String("string"),
    						Palette: pulumi.String("string"),
    					},
    				},
    				Style: &datadog.DashboardV2WidgetBarChartDefinitionStyleArgs{
    					Display: &datadog.DashboardV2WidgetBarChartDefinitionStyleDisplayArgs{
    						Flat: &datadog.DashboardV2WidgetBarChartDefinitionStyleDisplayFlatArgs{},
    						Stacked: &datadog.DashboardV2WidgetBarChartDefinitionStyleDisplayStackedArgs{
    							Legend: pulumi.String("string"),
    						},
    					},
    					Palette: pulumi.String("string"),
    					Scaling: pulumi.String("string"),
    				},
    				Time: &datadog.DashboardV2WidgetBarChartDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetBarChartDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetBarChartDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			ChangeDefinition: &datadog.DashboardV2WidgetChangeDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetChangeDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetChangeDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Requests: datadog.DashboardV2WidgetChangeDefinitionRequestArray{
    					&datadog.DashboardV2WidgetChangeDefinitionRequestArgs{
    						ChangeType: pulumi.String("string"),
    						CompareTo:  pulumi.String("string"),
    						Formulas: datadog.DashboardV2WidgetChangeDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetChangeDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetChangeDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						IncreaseGood: pulumi.Bool(false),
    						OrderBy:      pulumi.String("string"),
    						OrderDir:     pulumi.String("string"),
    						Queries: datadog.DashboardV2WidgetChangeDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetChangeDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetChangeDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						ShowPresent: pulumi.Bool(false),
    					},
    				},
    				Time: &datadog.DashboardV2WidgetChangeDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetChangeDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetChangeDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			CheckStatusDefinition: &datadog.DashboardV2WidgetCheckStatusDefinitionArgs{
    				Check:       pulumi.String("string"),
    				Grouping:    pulumi.String("string"),
    				Description: pulumi.String("string"),
    				Group:       pulumi.String("string"),
    				GroupBies: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Tags: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Time: &datadog.DashboardV2WidgetCheckStatusDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetCheckStatusDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetCheckStatusDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			DistributionDefinition: &datadog.DashboardV2WidgetDistributionDefinitionArgs{
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LegendSize:             pulumi.String("string"),
    				LiveSpan:               pulumi.String("string"),
    				Markers: datadog.DashboardV2WidgetDistributionDefinitionMarkerArray{
    					&datadog.DashboardV2WidgetDistributionDefinitionMarkerArgs{
    						Value:       pulumi.String("string"),
    						DisplayType: pulumi.String("string"),
    						Label:       pulumi.String("string"),
    						Time:        pulumi.String("string"),
    					},
    				},
    				Requests: datadog.DashboardV2WidgetDistributionDefinitionRequestArray{
    					&datadog.DashboardV2WidgetDistributionDefinitionRequestArgs{
    						ApmStatsQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestApmStatsQueryArgs{
    							Env:        pulumi.String("string"),
    							Name:       pulumi.String("string"),
    							PrimaryTag: pulumi.String("string"),
    							RowType:    pulumi.String("string"),
    							Service:    pulumi.String("string"),
    							Columns: datadog.DashboardV2WidgetDistributionDefinitionRequestApmStatsQueryColumnArray{
    								&datadog.DashboardV2WidgetDistributionDefinitionRequestApmStatsQueryColumnArgs{
    									Name:            pulumi.String("string"),
    									Alias:           pulumi.String("string"),
    									CellDisplayMode: pulumi.String("string"),
    									Order:           pulumi.String("string"),
    								},
    							},
    							Resource: pulumi.String("string"),
    						},
    						Formulas: datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetDistributionDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						HistogramQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryArgs{
    							ApmResourceStatsQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryApmResourceStatsQueryArgs{
    								DataSource:    pulumi.String("string"),
    								Env:           pulumi.String("string"),
    								Name:          pulumi.String("string"),
    								Service:       pulumi.String("string"),
    								Stat:          pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								GroupBies: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								OperationName:   pulumi.String("string"),
    								PrimaryTagName:  pulumi.String("string"),
    								PrimaryTagValue: pulumi.String("string"),
    								ResourceName:    pulumi.String("string"),
    							},
    							EventQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryArgs{
    								Computes: datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArray{
    									&datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArgs{
    										Aggregation: pulumi.String("string"),
    										Interval:    pulumi.Int(0),
    										Metric:      pulumi.String("string"),
    									},
    								},
    								DataSource:    pulumi.String("string"),
    								Name:          pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								GroupBies: datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArray{
    									&datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArgs{
    										Facet: pulumi.String("string"),
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupBySortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    								},
    								GroupByFields: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsArgs{
    									Fields: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Limit: pulumi.Int(0),
    									Sort: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsSortArgs{
    										Aggregation: pulumi.String("string"),
    										Metric:      pulumi.String("string"),
    										Order:       pulumi.String("string"),
    									},
    								},
    								Indexes: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								Search: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryEventQuerySearchArgs{
    									Query: pulumi.String("string"),
    								},
    								Storage: pulumi.String("string"),
    							},
    							MetricQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestHistogramQueryMetricQueryArgs{
    								Name:          pulumi.String("string"),
    								Query:         pulumi.String("string"),
    								Aggregator:    pulumi.String("string"),
    								CrossOrgUuids: pulumi.String("string"),
    								DataSource:    pulumi.String("string"),
    								SemanticMode:  pulumi.String("string"),
    							},
    						},
    						Queries: datadog.DashboardV2WidgetDistributionDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetDistributionDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetDistributionDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						RequestType: pulumi.String("string"),
    						Style: &datadog.DashboardV2WidgetDistributionDefinitionRequestStyleArgs{
    							OrderBy: pulumi.String("string"),
    							Palette: pulumi.String("string"),
    						},
    					},
    				},
    				ShowLegend: pulumi.Bool(false),
    				Time: &datadog.DashboardV2WidgetDistributionDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetDistributionDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetDistributionDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Xaxis: &datadog.DashboardV2WidgetDistributionDefinitionXaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					NumBuckets:  pulumi.Int(0),
    					Scale:       pulumi.String("string"),
    				},
    				Yaxis: &datadog.DashboardV2WidgetDistributionDefinitionYaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    			},
    			EventStreamDefinition: &datadog.DashboardV2WidgetEventStreamDefinitionArgs{
    				Query:                  pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				EventSize:              pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				TagsExecution:          pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetEventStreamDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetEventStreamDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetEventStreamDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			EventTimelineDefinition: &datadog.DashboardV2WidgetEventTimelineDefinitionArgs{
    				Query:                  pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				TagsExecution:          pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetEventTimelineDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetEventTimelineDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetEventTimelineDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			FreeTextDefinition: &datadog.DashboardV2WidgetFreeTextDefinitionArgs{
    				Text:                   pulumi.String("string"),
    				BackgroundColor:        pulumi.String("string"),
    				Color:                  pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				FontSize:               pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				TextAlign:              pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetFreeTextDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetFreeTextDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetFreeTextDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			FunnelDefinition: &datadog.DashboardV2WidgetFunnelDefinitionArgs{
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Request: &datadog.DashboardV2WidgetFunnelDefinitionRequestArgs{
    					Query: &datadog.DashboardV2WidgetFunnelDefinitionRequestQueryArgs{
    						DataSource:  pulumi.String("string"),
    						QueryString: pulumi.String("string"),
    						Steps: datadog.DashboardV2WidgetFunnelDefinitionRequestQueryStepArray{
    							&datadog.DashboardV2WidgetFunnelDefinitionRequestQueryStepArgs{
    								Facet: pulumi.String("string"),
    								Value: pulumi.String("string"),
    							},
    						},
    					},
    				},
    				Time: &datadog.DashboardV2WidgetFunnelDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetFunnelDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetFunnelDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			GeomapDefinition: &datadog.DashboardV2WidgetGeomapDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetGeomapDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetGeomapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Requests: datadog.DashboardV2WidgetGeomapDefinitionRequestArray{
    					&datadog.DashboardV2WidgetGeomapDefinitionRequestArgs{
    						Formulas: datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetGeomapDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetGeomapDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetGeomapDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetGeomapDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    				},
    				Style: &datadog.DashboardV2WidgetGeomapDefinitionStyleArgs{
    					Palette:     pulumi.String("string"),
    					PaletteFlip: pulumi.Bool(false),
    				},
    				Time: &datadog.DashboardV2WidgetGeomapDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetGeomapDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetGeomapDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				View: &datadog.DashboardV2WidgetGeomapDefinitionViewArgs{
    					Focus: pulumi.String("string"),
    				},
    			},
    			GroupDefinition: &datadog.DashboardV2WidgetGroupDefinitionArgs{
    				LayoutType:             pulumi.String("string"),
    				BackgroundColor:        pulumi.String("string"),
    				BannerImg:              pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				ShowTitle:              pulumi.Bool(false),
    				Time: &datadog.DashboardV2WidgetGroupDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetGroupDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetGroupDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Widgets: datadog.DashboardV2WidgetGroupDefinitionWidgetArray{
    					&datadog.DashboardV2WidgetGroupDefinitionWidgetArgs{
    						AlertGraphDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionArgs{
    							AlertId:                pulumi.String("string"),
    							VizType:                pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertGraphDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						AlertValueDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionArgs{
    							AlertId:                pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Precision:              pulumi.Int(0),
    							TextAlign:              pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetAlertValueDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Unit:       pulumi.String("string"),
    						},
    						BarChartDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Request: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestArgs{
    								ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    								Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortArgs{
    									Count: pulumi.Int(0),
    									OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByArgs{
    											FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByFormulaSortArgs{
    												Index: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestSortOrderByGroupSortArgs{
    												Name:  pulumi.String("string"),
    												Order: pulumi.String("string"),
    											},
    										},
    									},
    								},
    								Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionRequestStyleArgs{
    									OrderBy: pulumi.String("string"),
    									Palette: pulumi.String("string"),
    								},
    							},
    							Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleArgs{
    								Display: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleDisplayArgs{
    									Flat: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleDisplayFlatArgs{},
    									Stacked: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionStyleDisplayStackedArgs{
    										Legend: pulumi.String("string"),
    									},
    								},
    								Palette: pulumi.String("string"),
    								Scaling: pulumi.String("string"),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetBarChartDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ChangeDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestArgs{
    									ChangeType: pulumi.String("string"),
    									CompareTo:  pulumi.String("string"),
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									IncreaseGood: pulumi.Bool(false),
    									OrderBy:      pulumi.String("string"),
    									OrderDir:     pulumi.String("string"),
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									ShowPresent: pulumi.Bool(false),
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetChangeDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						CheckStatusDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionArgs{
    							Check:       pulumi.String("string"),
    							Grouping:    pulumi.String("string"),
    							Description: pulumi.String("string"),
    							Group:       pulumi.String("string"),
    							GroupBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Tags: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetCheckStatusDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						DistributionDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionArgs{
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LegendSize:             pulumi.String("string"),
    							LiveSpan:               pulumi.String("string"),
    							Markers: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionMarkerArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionMarkerArgs{
    									Value:       pulumi.String("string"),
    									DisplayType: pulumi.String("string"),
    									Label:       pulumi.String("string"),
    									Time:        pulumi.String("string"),
    								},
    							},
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestArgs{
    									ApmStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryArgs{
    										Env:        pulumi.String("string"),
    										Name:       pulumi.String("string"),
    										PrimaryTag: pulumi.String("string"),
    										RowType:    pulumi.String("string"),
    										Service:    pulumi.String("string"),
    										Columns: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryColumnArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs{
    												Name:            pulumi.String("string"),
    												Alias:           pulumi.String("string"),
    												CellDisplayMode: pulumi.String("string"),
    												Order:           pulumi.String("string"),
    											},
    										},
    										Resource: pulumi.String("string"),
    									},
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									HistogramQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryArgs{
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestHistogramQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									RequestType: pulumi.String("string"),
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionRequestStyleArgs{
    										OrderBy: pulumi.String("string"),
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							ShowLegend: pulumi.Bool(false),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Xaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionXaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								NumBuckets:  pulumi.Int(0),
    								Scale:       pulumi.String("string"),
    							},
    							Yaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetDistributionDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						EventStreamDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionArgs{
    							Query:                  pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							EventSize:              pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							TagsExecution:          pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventStreamDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						EventTimelineDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionArgs{
    							Query:                  pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							TagsExecution:          pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetEventTimelineDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						FreeTextDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionArgs{
    							Text:                   pulumi.String("string"),
    							BackgroundColor:        pulumi.String("string"),
    							Color:                  pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							FontSize:               pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							TextAlign:              pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetFreeTextDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						FunnelDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionArgs{
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Request: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestArgs{
    								Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestQueryArgs{
    									DataSource:  pulumi.String("string"),
    									QueryString: pulumi.String("string"),
    									Steps: datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestQueryStepArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionRequestQueryStepArgs{
    											Facet: pulumi.String("string"),
    											Value: pulumi.String("string"),
    										},
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetFunnelDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						GeomapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    							Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionStyleArgs{
    								Palette:     pulumi.String("string"),
    								PaletteFlip: pulumi.Bool(false),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							View: &datadog.DashboardV2WidgetGroupDefinitionWidgetGeomapDefinitionViewArgs{
    								Focus: pulumi.String("string"),
    							},
    						},
    						HeatmapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description: pulumi.String("string"),
    							Events: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionEventArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionEventArgs{
    									Q:             pulumi.String("string"),
    									TagsExecution: pulumi.String("string"),
    								},
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							LegendSize:             pulumi.String("string"),
    							LiveSpan:               pulumi.String("string"),
    							Markers: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionMarkerArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionMarkerArgs{
    									Value:       pulumi.String("string"),
    									DisplayType: pulumi.String("string"),
    									Label:       pulumi.String("string"),
    									Time:        pulumi.String("string"),
    								},
    							},
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionRequestStyleArgs{
    										OrderBy: pulumi.String("string"),
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							ShowLegend: pulumi.Bool(false),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Xaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionXaxisArgs{
    								NumBuckets: pulumi.Int(0),
    							},
    							Yaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetHeatmapDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						HostmapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description: pulumi.String("string"),
    							Groups: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							NoGroupHosts:           pulumi.Bool(false),
    							NoMetricHosts:          pulumi.Bool(false),
    							NodeType:               pulumi.String("string"),
    							Notes:                  pulumi.String("string"),
    							Request: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestArgs{
    								Fill: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestFillQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    								Size: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    							Scopes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionStyleArgs{
    								FillMax:     pulumi.String("string"),
    								FillMin:     pulumi.String("string"),
    								Palette:     pulumi.String("string"),
    								PaletteFlip: pulumi.Bool(false),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetHostmapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						Id: pulumi.Int(0),
    						IframeDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionArgs{
    							Url:                    pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetIframeDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ImageDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionArgs{
    							Url:    pulumi.String("string"),
    							Margin: pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetImageDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							HorizontalAlign:        pulumi.String("string"),
    							LiveSpan:               pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							Sizing:                 pulumi.String("string"),
    							HasBorder:              pulumi.Bool(false),
    							Title:                  pulumi.String("string"),
    							TitleAlign:             pulumi.String("string"),
    							TitleSize:              pulumi.String("string"),
    							HasBackground:          pulumi.Bool(false),
    							UrlDarkTheme:           pulumi.String("string"),
    							VerticalAlign:          pulumi.String("string"),
    						},
    						ListStreamDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionArgs{
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestArgs{
    									Columns: datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestColumnArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestColumnArgs{
    											Field: pulumi.String("string"),
    											Width: pulumi.String("string"),
    										},
    									},
    									Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryArgs{
    										DataSource:                 pulumi.String("string"),
    										ClusteringPatternFieldPath: pulumi.String("string"),
    										EventSize:                  pulumi.String("string"),
    										GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryGroupByArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    											},
    										},
    										Indexes: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										QueryString: pulumi.String("string"),
    										Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionRequestQuerySortArgs{
    											Column: pulumi.String("string"),
    											Order:  pulumi.String("string"),
    										},
    										Storage: pulumi.String("string"),
    									},
    									ResponseFormat: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LegendSize:             pulumi.String("string"),
    							LiveSpan:               pulumi.String("string"),
    							ShowLegend:             pulumi.Bool(false),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetListStreamDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						LogStreamDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionArgs{
    							Columns: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							Indexes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							LiveSpan:          pulumi.String("string"),
    							MessageDisplay:    pulumi.String("string"),
    							Query:             pulumi.String("string"),
    							ShowDateColumn:    pulumi.Bool(false),
    							ShowMessageColumn: pulumi.Bool(false),
    							Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionSortArgs{
    								Column: pulumi.String("string"),
    								Order:  pulumi.String("string"),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetLogStreamDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ManageStatusDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionArgs{
    							Query:                  pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							ShowPriority:           pulumi.Bool(false),
    							ColorPreference:        pulumi.String("string"),
    							HideZeroCounts:         pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							ShowLastTriggered:      pulumi.Bool(false),
    							DisplayFormat:          pulumi.String("string"),
    							Sort:                   pulumi.String("string"),
    							SummaryType:            pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetManageStatusDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						NoteDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionArgs{
    							Content:   pulumi.String("string"),
    							TextAlign: pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetNoteDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							FontSize:               pulumi.String("string"),
    							HasPadding:             pulumi.Bool(false),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							TickEdge:               pulumi.String("string"),
    							ShowTick:               pulumi.Bool(false),
    							TickPos:                pulumi.String("string"),
    							BackgroundColor:        pulumi.String("string"),
    							Title:                  pulumi.String("string"),
    							TitleAlign:             pulumi.String("string"),
    							TitleSize:              pulumi.String("string"),
    							VerticalAlign:          pulumi.String("string"),
    						},
    						QueryTableDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HasSearchBar:           pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestArgs{
    									Aggregator: pulumi.String("string"),
    									Alias:      pulumi.String("string"),
    									CellDisplayModes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestConditionalFormatArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestConditionalFormatArgs{
    											Comparator:    pulumi.String("string"),
    											Palette:       pulumi.String("string"),
    											Value:         pulumi.Float64(0),
    											CustomBgColor: pulumi.String("string"),
    											CustomFgColor: pulumi.String("string"),
    											HideValue:     pulumi.Bool(false),
    											ImageUrl:      pulumi.String("string"),
    											Metric:        pulumi.String("string"),
    											Timeframe:     pulumi.String("string"),
    										},
    									},
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Limit: pulumi.Int(0),
    									Order: pulumi.String("string"),
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									TextFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatArgs{
    											TextFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs{
    													Match: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs{
    														Type:  pulumi.String("string"),
    														Value: pulumi.String("string"),
    													},
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Replace: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs{
    														Type:      pulumi.String("string"),
    														With:      pulumi.String("string"),
    														Substring: pulumi.String("string"),
    													},
    												},
    											},
    										},
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryTableDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						QueryValueDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionArgs{
    							Autoscale: pulumi.Bool(false),
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							CustomUnit:             pulumi.String("string"),
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Precision:              pulumi.Int(0),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestArgs{
    									Aggregator: pulumi.String("string"),
    									ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestConditionalFormatArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestConditionalFormatArgs{
    											Comparator:    pulumi.String("string"),
    											Palette:       pulumi.String("string"),
    											Value:         pulumi.Float64(0),
    											CustomBgColor: pulumi.String("string"),
    											CustomFgColor: pulumi.String("string"),
    											HideValue:     pulumi.Bool(false),
    											ImageUrl:      pulumi.String("string"),
    											Metric:        pulumi.String("string"),
    											Timeframe:     pulumi.String("string"),
    										},
    									},
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    							TextAlign: pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							TimeseriesBackground: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundArgs{
    								Type: pulumi.String("string"),
    								Yaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs{
    									IncludeZero: pulumi.Bool(false),
    									Label:       pulumi.String("string"),
    									Max:         pulumi.String("string"),
    									Min:         pulumi.String("string"),
    									Scale:       pulumi.String("string"),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						RunWorkflowDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionArgs{
    							WorkflowId: pulumi.String("string"),
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							Inputs: datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionInputTypeArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionInputTypeArgs{
    									Name:  pulumi.String("string"),
    									Value: pulumi.String("string"),
    								},
    							},
    							LiveSpan: pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetRunWorkflowDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						SankeyDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionArgs{
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestArgs{
    									NetworkRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestArgs{
    										Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQueryArgs{
    											DataSource: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit:       pulumi.Int(0),
    											QueryString: pulumi.String("string"),
    											Compute: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQueryComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    											},
    											Mode:                 pulumi.String("string"),
    											ShouldExcludeMissing: pulumi.Bool(false),
    											Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestNetworkRequestQuerySortArgs{
    												Field: pulumi.String("string"),
    												Order: pulumi.String("string"),
    											},
    										},
    									},
    									RumRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestRumRequestArgs{
    										Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionRequestRumRequestQueryArgs{
    											DataSource:     pulumi.String("string"),
    											Mode:           pulumi.String("string"),
    											QueryString:    pulumi.String("string"),
    											EntriesPerStep: pulumi.Int(0),
    											NumberOfSteps:  pulumi.Int(0),
    											Source:         pulumi.String("string"),
    											SubqueryId:     pulumi.String("string"),
    											Target:         pulumi.String("string"),
    										},
    									},
    								},
    							},
    							ShowOtherLinks: pulumi.Bool(false),
    							SortNodes:      pulumi.Bool(false),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetSankeyDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ScatterplotDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionArgs{
    							ColorByGroups: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Request: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestArgs{
    								ScatterplotTables: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableArray{
    									&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableArgs{
    										Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableFormulaArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs{
    												Dimension:         pulumi.String("string"),
    												FormulaExpression: pulumi.String("string"),
    												Alias:             pulumi.String("string"),
    											},
    										},
    										Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs{
    												ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Env:             pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													OperationName:   pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    													Service:         pulumi.String("string"),
    													Stat:            pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsUpstream:      pulumi.Bool(false),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    												},
    												ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Env:           pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Service:       pulumi.String("string"),
    													Stat:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													OperationName:   pulumi.String("string"),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    												},
    												CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    												},
    												EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs{
    													Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    															Metric:      pulumi.String("string"),
    														},
    													},
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs{
    																Aggregation: pulumi.String("string"),
    																Metric:      pulumi.String("string"),
    																Order:       pulumi.String("string"),
    															},
    														},
    													},
    													GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs{
    														Fields: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    													Indexes: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs{
    														Query: pulumi.String("string"),
    													},
    													Storage: pulumi.String("string"),
    												},
    												MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs{
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													DataSource:    pulumi.String("string"),
    													SemanticMode:  pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Metric:          pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													Aggregator:      pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsNormalizedCpu: pulumi.Bool(false),
    													Limit:           pulumi.Int(0),
    													Sort:            pulumi.String("string"),
    													TagFilters: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													TextFilter: pulumi.String("string"),
    												},
    												SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs{
    													DataSource:             pulumi.String("string"),
    													Measure:                pulumi.String("string"),
    													SloId:                  pulumi.String("string"),
    													AdditionalQueryFilters: pulumi.String("string"),
    													CrossOrgUuids:          pulumi.String("string"),
    													GroupMode:              pulumi.String("string"),
    													Name:                   pulumi.String("string"),
    													SloQueryType:           pulumi.String("string"),
    												},
    											},
    										},
    									},
    								},
    								X: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXArgs{
    									Aggregator: pulumi.String("string"),
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestXQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    								Y: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYArgs{
    									Aggregator: pulumi.String("string"),
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionRequestYQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Xaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionXaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    							Yaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetScatterplotDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						ServiceLevelObjectiveDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionArgs{
    							SloId:    pulumi.String("string"),
    							ViewType: pulumi.String("string"),
    							ViewMode: pulumi.String("string"),
    							TimeWindows: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							ShowErrorBudget:        pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							AdditionalQueryFilters: pulumi.String("string"),
    							Title:                  pulumi.String("string"),
    							TitleAlign:             pulumi.String("string"),
    							TitleSize:              pulumi.String("string"),
    							GlobalTimeTarget:       pulumi.String("string"),
    							Description:            pulumi.String("string"),
    						},
    						ServicemapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionArgs{
    							Filters: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Service: pulumi.String("string"),
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetServicemapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						SloListDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionArgs{
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestArgs{
    									Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestQueryArgs{
    										QueryString: pulumi.String("string"),
    										Limit:       pulumi.Int(0),
    										Sorts: datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestQuerySortArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionRequestQuerySortArgs{
    												Column: pulumi.String("string"),
    												Order:  pulumi.String("string"),
    											},
    										},
    									},
    									RequestType: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetSloListDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						SunburstDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							HideTotal:              pulumi.Bool(false),
    							LegendInline: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionLegendInlineArgs{
    								Type:        pulumi.String("string"),
    								HidePercent: pulumi.Bool(false),
    								HideValue:   pulumi.Bool(false),
    							},
    							LegendTable: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionLegendTableArgs{
    								Type: pulumi.String("string"),
    							},
    							LiveSpan: pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortArgs{
    										Count: pulumi.Int(0),
    										OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByArgs{
    												FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByFormulaSortArgs{
    													Index: pulumi.Int(0),
    													Order: pulumi.String("string"),
    												},
    												GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestSortOrderByGroupSortArgs{
    													Name:  pulumi.String("string"),
    													Order: pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionRequestStyleArgs{
    										OrderBy: pulumi.String("string"),
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetSunburstDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						TimeseriesDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description: pulumi.String("string"),
    							Events: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionEventArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionEventArgs{
    									Q:             pulumi.String("string"),
    									TagsExecution: pulumi.String("string"),
    								},
    							},
    							HideIncompleteCostData: pulumi.Bool(false),
    							LegendColumns: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							LegendLayout: pulumi.String("string"),
    							LegendSize:   pulumi.String("string"),
    							LiveSpan:     pulumi.String("string"),
    							Markers: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionMarkerArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionMarkerArgs{
    									Value:       pulumi.String("string"),
    									DisplayType: pulumi.String("string"),
    									Label:       pulumi.String("string"),
    									Time:        pulumi.String("string"),
    								},
    							},
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestArgs{
    									DisplayType: pulumi.String("string"),
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Metadatas: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestMetadataArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestMetadataArgs{
    											Expression: pulumi.String("string"),
    											AliasName:  pulumi.String("string"),
    										},
    									},
    									OnRightYaxis: pulumi.Bool(false),
    									ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRequestStyleArgs{
    										HasValueLabels: pulumi.Bool(false),
    										LineType:       pulumi.String("string"),
    										LineWidth:      pulumi.String("string"),
    										OrderBy:        pulumi.String("string"),
    										Palette:        pulumi.String("string"),
    									},
    								},
    							},
    							RightYaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionRightYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    							ShowLegend: pulumi.Bool(false),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Yaxis: &datadog.DashboardV2WidgetGroupDefinitionWidgetTimeseriesDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						ToplistDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestArgs{
    									ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestConditionalFormatArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestConditionalFormatArgs{
    											Comparator:    pulumi.String("string"),
    											Palette:       pulumi.String("string"),
    											Value:         pulumi.Float64(0),
    											CustomBgColor: pulumi.String("string"),
    											CustomFgColor: pulumi.String("string"),
    											HideValue:     pulumi.Bool(false),
    											ImageUrl:      pulumi.String("string"),
    											Metric:        pulumi.String("string"),
    											Timeframe:     pulumi.String("string"),
    										},
    									},
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortArgs{
    										Count: pulumi.Int(0),
    										OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByArgs{
    												FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByFormulaSortArgs{
    													Index: pulumi.Int(0),
    													Order: pulumi.String("string"),
    												},
    												GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestSortOrderByGroupSortArgs{
    													Name:  pulumi.String("string"),
    													Order: pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionRequestStyleArgs{
    										OrderBy: pulumi.String("string"),
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleArgs{
    								Display: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleDisplayArgs{
    									Flat: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleDisplayFlatArgs{},
    									Stacked: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionStyleDisplayStackedArgs{
    										Legend: pulumi.String("string"),
    									},
    								},
    								Palette: pulumi.String("string"),
    								Scaling: pulumi.String("string"),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetToplistDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						TopologyMapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionRequestArgs{
    									RequestType: pulumi.String("string"),
    									Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionRequestQueryArgs{
    										DataSource: pulumi.String("string"),
    										Filters: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Service: pulumi.String("string"),
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetTopologyMapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						TraceServiceDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionArgs{
    							Service:                pulumi.String("string"),
    							SpanName:               pulumi.String("string"),
    							Env:                    pulumi.String("string"),
    							ShowErrors:             pulumi.Bool(false),
    							ShowLatency:            pulumi.Bool(false),
    							HideIncompleteCostData: pulumi.Bool(false),
    							ShowBreakdown:          pulumi.Bool(false),
    							ShowDistribution:       pulumi.Bool(false),
    							Description:            pulumi.String("string"),
    							ShowHits:               pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							ShowResourceList:       pulumi.Bool(false),
    							SizeFormat:             pulumi.String("string"),
    							DisplayFormat:          pulumi.String("string"),
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetTraceServiceDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						TreemapDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestArgs{
    									Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs{
    													Comparator:    pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Value:         pulumi.Float64(0),
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													HideValue:     pulumi.Bool(false),
    													ImageUrl:      pulumi.String("string"),
    													Metric:        pulumi.String("string"),
    													Timeframe:     pulumi.String("string"),
    												},
    											},
    											Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														PerUnitName: pulumi.String("string"),
    														UnitName:    pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryArray{
    										&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    									Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortArgs{
    										Count: pulumi.Int(0),
    										OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByArgs{
    												FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByFormulaSortArgs{
    													Index: pulumi.Int(0),
    													Order: pulumi.String("string"),
    												},
    												GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestSortOrderByGroupSortArgs{
    													Name:  pulumi.String("string"),
    													Order: pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionRequestStyleArgs{
    										OrderBy: pulumi.String("string"),
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetTreemapDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						WidgetLayout: &datadog.DashboardV2WidgetGroupDefinitionWidgetWidgetLayoutArgs{
    							Height:        pulumi.Int(0),
    							Width:         pulumi.Int(0),
    							X:             pulumi.Int(0),
    							Y:             pulumi.Int(0),
    							IsColumnBreak: pulumi.Bool(false),
    						},
    						WildcardDefinition: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionArgs{
    							CustomLinks: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionCustomLinkArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Description:            pulumi.String("string"),
    							HideIncompleteCostData: pulumi.Bool(false),
    							LiveSpan:               pulumi.String("string"),
    							Requests: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestArray{
    								&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestArgs{
    									HistogramRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestArgs{
    										HistogramQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryArgs{
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestHistogramQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestHistogramRequestStyleArgs{
    											OrderBy: pulumi.String("string"),
    											Palette: pulumi.String("string"),
    										},
    									},
    									ListstreamRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestArgs{
    										Columns: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestColumnArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestColumnArgs{
    												Field: pulumi.String("string"),
    												Width: pulumi.String("string"),
    											},
    										},
    										Query: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQueryArgs{
    											DataSource:                 pulumi.String("string"),
    											ClusteringPatternFieldPath: pulumi.String("string"),
    											EventSize:                  pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQueryGroupByArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											QueryString: pulumi.String("string"),
    											Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestListstreamRequestQuerySortArgs{
    												Column: pulumi.String("string"),
    												Order:  pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    									},
    									TimeseriesRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestArgs{
    										DisplayType: pulumi.String("string"),
    										Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaArgs{
    												FormulaExpression: pulumi.String("string"),
    												Alias:             pulumi.String("string"),
    												CellDisplayMode:   pulumi.String("string"),
    												CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaCellDisplayModeOptionsArgs{
    													TrendType: pulumi.String("string"),
    													YScale:    pulumi.String("string"),
    												},
    												ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaConditionalFormatArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaConditionalFormatArgs{
    														Comparator:    pulumi.String("string"),
    														Palette:       pulumi.String("string"),
    														Value:         pulumi.Float64(0),
    														CustomBgColor: pulumi.String("string"),
    														CustomFgColor: pulumi.String("string"),
    														HideValue:     pulumi.Bool(false),
    														ImageUrl:      pulumi.String("string"),
    														Metric:        pulumi.String("string"),
    														Timeframe:     pulumi.String("string"),
    													},
    												},
    												Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaLimitArgs{
    													Count: pulumi.Int(0),
    													Order: pulumi.String("string"),
    												},
    												NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatArgs{
    													Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitArgs{
    														Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCanonicalArgs{
    															PerUnitName: pulumi.String("string"),
    															UnitName:    pulumi.String("string"),
    														},
    														Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitCustomArgs{
    															Label: pulumi.String("string"),
    														},
    													},
    													UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaNumberFormatUnitScaleArgs{
    														UnitName: pulumi.String("string"),
    													},
    												},
    												Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestFormulaStyleArgs{
    													Palette:      pulumi.String("string"),
    													PaletteIndex: pulumi.Int(0),
    												},
    											},
    										},
    										Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryArgs{
    												ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryApmDependencyStatsQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Env:             pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													OperationName:   pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    													Service:         pulumi.String("string"),
    													Stat:            pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsUpstream:      pulumi.Bool(false),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    												},
    												ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryApmResourceStatsQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Env:           pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Service:       pulumi.String("string"),
    													Stat:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													OperationName:   pulumi.String("string"),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    												},
    												CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryCloudCostQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    												},
    												EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryArgs{
    													Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryComputeArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    															Metric:      pulumi.String("string"),
    														},
    													},
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupBySortArgs{
    																Aggregation: pulumi.String("string"),
    																Metric:      pulumi.String("string"),
    																Order:       pulumi.String("string"),
    															},
    														},
    													},
    													GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsArgs{
    														Fields: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQueryGroupByFieldsSortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    													Indexes: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryEventQuerySearchArgs{
    														Query: pulumi.String("string"),
    													},
    													Storage: pulumi.String("string"),
    												},
    												MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryMetricQueryArgs{
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													DataSource:    pulumi.String("string"),
    													SemanticMode:  pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQueryProcessQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Metric:          pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													Aggregator:      pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsNormalizedCpu: pulumi.Bool(false),
    													Limit:           pulumi.Int(0),
    													Sort:            pulumi.String("string"),
    													TagFilters: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													TextFilter: pulumi.String("string"),
    												},
    												SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestQuerySloQueryArgs{
    													DataSource:             pulumi.String("string"),
    													Measure:                pulumi.String("string"),
    													SloId:                  pulumi.String("string"),
    													AdditionalQueryFilters: pulumi.String("string"),
    													CrossOrgUuids:          pulumi.String("string"),
    													GroupMode:              pulumi.String("string"),
    													Name:                   pulumi.String("string"),
    													SloQueryType:           pulumi.String("string"),
    												},
    											},
    										},
    										Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortArgs{
    											Count: pulumi.Int(0),
    											OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByArgs{
    													FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByFormulaSortArgs{
    														Index: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestSortOrderByGroupSortArgs{
    														Name:  pulumi.String("string"),
    														Order: pulumi.String("string"),
    													},
    												},
    											},
    										},
    										Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTimeseriesRequestStyleArgs{
    											OrderBy: pulumi.String("string"),
    											Palette: pulumi.String("string"),
    										},
    									},
    									TreemapRequest: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestArgs{
    										Formulas: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaArgs{
    												FormulaExpression: pulumi.String("string"),
    												Alias:             pulumi.String("string"),
    												CellDisplayMode:   pulumi.String("string"),
    												CellDisplayModeOptions: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaCellDisplayModeOptionsArgs{
    													TrendType: pulumi.String("string"),
    													YScale:    pulumi.String("string"),
    												},
    												ConditionalFormats: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaConditionalFormatArray{
    													&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaConditionalFormatArgs{
    														Comparator:    pulumi.String("string"),
    														Palette:       pulumi.String("string"),
    														Value:         pulumi.Float64(0),
    														CustomBgColor: pulumi.String("string"),
    														CustomFgColor: pulumi.String("string"),
    														HideValue:     pulumi.Bool(false),
    														ImageUrl:      pulumi.String("string"),
    														Metric:        pulumi.String("string"),
    														Timeframe:     pulumi.String("string"),
    													},
    												},
    												Limit: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaLimitArgs{
    													Count: pulumi.Int(0),
    													Order: pulumi.String("string"),
    												},
    												NumberFormat: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatArgs{
    													Unit: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitArgs{
    														Canonical: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCanonicalArgs{
    															PerUnitName: pulumi.String("string"),
    															UnitName:    pulumi.String("string"),
    														},
    														Custom: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitCustomArgs{
    															Label: pulumi.String("string"),
    														},
    													},
    													UnitScale: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaNumberFormatUnitScaleArgs{
    														UnitName: pulumi.String("string"),
    													},
    												},
    												Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestFormulaStyleArgs{
    													Palette:      pulumi.String("string"),
    													PaletteIndex: pulumi.Int(0),
    												},
    											},
    										},
    										Queries: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryArray{
    											&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryArgs{
    												ApmDependencyStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryApmDependencyStatsQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Env:             pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													OperationName:   pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    													Service:         pulumi.String("string"),
    													Stat:            pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsUpstream:      pulumi.Bool(false),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    												},
    												ApmResourceStatsQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryApmResourceStatsQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Env:           pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Service:       pulumi.String("string"),
    													Stat:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													OperationName:   pulumi.String("string"),
    													PrimaryTagName:  pulumi.String("string"),
    													PrimaryTagValue: pulumi.String("string"),
    													ResourceName:    pulumi.String("string"),
    												},
    												CloudCostQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryCloudCostQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    												},
    												EventQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryArgs{
    													Computes: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryComputeArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    															Metric:      pulumi.String("string"),
    														},
    													},
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													GroupBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByArray{
    														&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupBySortArgs{
    																Aggregation: pulumi.String("string"),
    																Metric:      pulumi.String("string"),
    																Order:       pulumi.String("string"),
    															},
    														},
    													},
    													GroupByFields: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsArgs{
    														Fields: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQueryGroupByFieldsSortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    													Indexes: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Search: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryEventQuerySearchArgs{
    														Query: pulumi.String("string"),
    													},
    													Storage: pulumi.String("string"),
    												},
    												MetricQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryMetricQueryArgs{
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													DataSource:    pulumi.String("string"),
    													SemanticMode:  pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQueryProcessQueryArgs{
    													DataSource:      pulumi.String("string"),
    													Metric:          pulumi.String("string"),
    													Name:            pulumi.String("string"),
    													Aggregator:      pulumi.String("string"),
    													CrossOrgUuids:   pulumi.String("string"),
    													IsNormalizedCpu: pulumi.Bool(false),
    													Limit:           pulumi.Int(0),
    													Sort:            pulumi.String("string"),
    													TagFilters: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													TextFilter: pulumi.String("string"),
    												},
    												SloQuery: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestQuerySloQueryArgs{
    													DataSource:             pulumi.String("string"),
    													Measure:                pulumi.String("string"),
    													SloId:                  pulumi.String("string"),
    													AdditionalQueryFilters: pulumi.String("string"),
    													CrossOrgUuids:          pulumi.String("string"),
    													GroupMode:              pulumi.String("string"),
    													Name:                   pulumi.String("string"),
    													SloQueryType:           pulumi.String("string"),
    												},
    											},
    										},
    										Sort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortArgs{
    											Count: pulumi.Int(0),
    											OrderBies: datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByArray{
    												&datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByArgs{
    													FormulaSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByFormulaSortArgs{
    														Index: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													GroupSort: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestSortOrderByGroupSortArgs{
    														Name:  pulumi.String("string"),
    														Order: pulumi.String("string"),
    													},
    												},
    											},
    										},
    										Style: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionRequestTreemapRequestStyleArgs{
    											OrderBy: pulumi.String("string"),
    											Palette: pulumi.String("string"),
    										},
    									},
    								},
    							},
    							Specification: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionSpecificationArgs{
    								Contents: pulumi.String("string"),
    								Type:     pulumi.String("string"),
    							},
    							Time: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeArgs{
    								Fixed: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeFixedArgs{
    									From: pulumi.Int(0),
    									To:   pulumi.Int(0),
    								},
    								Live: &datadog.DashboardV2WidgetGroupDefinitionWidgetWildcardDefinitionTimeLiveArgs{
    									Unit:  pulumi.String("string"),
    									Value: pulumi.Int(0),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    					},
    				},
    			},
    			HeatmapDefinition: &datadog.DashboardV2WidgetHeatmapDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetHeatmapDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetHeatmapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description: pulumi.String("string"),
    				Events: datadog.DashboardV2WidgetHeatmapDefinitionEventArray{
    					&datadog.DashboardV2WidgetHeatmapDefinitionEventArgs{
    						Q:             pulumi.String("string"),
    						TagsExecution: pulumi.String("string"),
    					},
    				},
    				HideIncompleteCostData: pulumi.Bool(false),
    				LegendSize:             pulumi.String("string"),
    				LiveSpan:               pulumi.String("string"),
    				Markers: datadog.DashboardV2WidgetHeatmapDefinitionMarkerArray{
    					&datadog.DashboardV2WidgetHeatmapDefinitionMarkerArgs{
    						Value:       pulumi.String("string"),
    						DisplayType: pulumi.String("string"),
    						Label:       pulumi.String("string"),
    						Time:        pulumi.String("string"),
    					},
    				},
    				Requests: datadog.DashboardV2WidgetHeatmapDefinitionRequestArray{
    					&datadog.DashboardV2WidgetHeatmapDefinitionRequestArgs{
    						Formulas: datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetHeatmapDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetHeatmapDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						Style: &datadog.DashboardV2WidgetHeatmapDefinitionRequestStyleArgs{
    							OrderBy: pulumi.String("string"),
    							Palette: pulumi.String("string"),
    						},
    					},
    				},
    				ShowLegend: pulumi.Bool(false),
    				Time: &datadog.DashboardV2WidgetHeatmapDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetHeatmapDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetHeatmapDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Xaxis: &datadog.DashboardV2WidgetHeatmapDefinitionXaxisArgs{
    					NumBuckets: pulumi.Int(0),
    				},
    				Yaxis: &datadog.DashboardV2WidgetHeatmapDefinitionYaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    			},
    			HostmapDefinition: &datadog.DashboardV2WidgetHostmapDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetHostmapDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetHostmapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description: pulumi.String("string"),
    				Groups: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				NoGroupHosts:           pulumi.Bool(false),
    				NoMetricHosts:          pulumi.Bool(false),
    				NodeType:               pulumi.String("string"),
    				Notes:                  pulumi.String("string"),
    				Request: &datadog.DashboardV2WidgetHostmapDefinitionRequestArgs{
    					Fill: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillArgs{
    						Formulas: datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaArray{
    							&datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryArray{
    							&datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestFillQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    					Size: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeArgs{
    						Formulas: datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaArray{
    							&datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryArray{
    							&datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetHostmapDefinitionRequestSizeQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    				},
    				Scopes: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Style: &datadog.DashboardV2WidgetHostmapDefinitionStyleArgs{
    					FillMax:     pulumi.String("string"),
    					FillMin:     pulumi.String("string"),
    					Palette:     pulumi.String("string"),
    					PaletteFlip: pulumi.Bool(false),
    				},
    				Time: &datadog.DashboardV2WidgetHostmapDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetHostmapDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetHostmapDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			Id: pulumi.Int(0),
    			IframeDefinition: &datadog.DashboardV2WidgetIframeDefinitionArgs{
    				Url:                    pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetIframeDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetIframeDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetIframeDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			ImageDefinition: &datadog.DashboardV2WidgetImageDefinitionArgs{
    				Url:    pulumi.String("string"),
    				Margin: pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetImageDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetImageDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetImageDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				HideIncompleteCostData: pulumi.Bool(false),
    				HorizontalAlign:        pulumi.String("string"),
    				LiveSpan:               pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				Sizing:                 pulumi.String("string"),
    				HasBorder:              pulumi.Bool(false),
    				Title:                  pulumi.String("string"),
    				TitleAlign:             pulumi.String("string"),
    				TitleSize:              pulumi.String("string"),
    				HasBackground:          pulumi.Bool(false),
    				UrlDarkTheme:           pulumi.String("string"),
    				VerticalAlign:          pulumi.String("string"),
    			},
    			ListStreamDefinition: &datadog.DashboardV2WidgetListStreamDefinitionArgs{
    				Requests: datadog.DashboardV2WidgetListStreamDefinitionRequestArray{
    					&datadog.DashboardV2WidgetListStreamDefinitionRequestArgs{
    						Columns: datadog.DashboardV2WidgetListStreamDefinitionRequestColumnArray{
    							&datadog.DashboardV2WidgetListStreamDefinitionRequestColumnArgs{
    								Field: pulumi.String("string"),
    								Width: pulumi.String("string"),
    							},
    						},
    						Query: &datadog.DashboardV2WidgetListStreamDefinitionRequestQueryArgs{
    							DataSource:                 pulumi.String("string"),
    							ClusteringPatternFieldPath: pulumi.String("string"),
    							EventSize:                  pulumi.String("string"),
    							GroupBies: datadog.DashboardV2WidgetListStreamDefinitionRequestQueryGroupByArray{
    								&datadog.DashboardV2WidgetListStreamDefinitionRequestQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    								},
    							},
    							Indexes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							QueryString: pulumi.String("string"),
    							Sort: &datadog.DashboardV2WidgetListStreamDefinitionRequestQuerySortArgs{
    								Column: pulumi.String("string"),
    								Order:  pulumi.String("string"),
    							},
    							Storage: pulumi.String("string"),
    						},
    						ResponseFormat: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LegendSize:             pulumi.String("string"),
    				LiveSpan:               pulumi.String("string"),
    				ShowLegend:             pulumi.Bool(false),
    				Time: &datadog.DashboardV2WidgetListStreamDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetListStreamDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetListStreamDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			LogStreamDefinition: &datadog.DashboardV2WidgetLogStreamDefinitionArgs{
    				Columns: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				Indexes: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				LiveSpan:          pulumi.String("string"),
    				MessageDisplay:    pulumi.String("string"),
    				Query:             pulumi.String("string"),
    				ShowDateColumn:    pulumi.Bool(false),
    				ShowMessageColumn: pulumi.Bool(false),
    				Sort: &datadog.DashboardV2WidgetLogStreamDefinitionSortArgs{
    					Column: pulumi.String("string"),
    					Order:  pulumi.String("string"),
    				},
    				Time: &datadog.DashboardV2WidgetLogStreamDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetLogStreamDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetLogStreamDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			ManageStatusDefinition: &datadog.DashboardV2WidgetManageStatusDefinitionArgs{
    				Query:                  pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				ShowPriority:           pulumi.Bool(false),
    				ColorPreference:        pulumi.String("string"),
    				HideZeroCounts:         pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				ShowLastTriggered:      pulumi.Bool(false),
    				DisplayFormat:          pulumi.String("string"),
    				Sort:                   pulumi.String("string"),
    				SummaryType:            pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetManageStatusDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetManageStatusDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetManageStatusDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			NoteDefinition: &datadog.DashboardV2WidgetNoteDefinitionArgs{
    				Content:   pulumi.String("string"),
    				TextAlign: pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetNoteDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetNoteDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetNoteDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				FontSize:               pulumi.String("string"),
    				HasPadding:             pulumi.Bool(false),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				TickEdge:               pulumi.String("string"),
    				ShowTick:               pulumi.Bool(false),
    				TickPos:                pulumi.String("string"),
    				BackgroundColor:        pulumi.String("string"),
    				Title:                  pulumi.String("string"),
    				TitleAlign:             pulumi.String("string"),
    				TitleSize:              pulumi.String("string"),
    				VerticalAlign:          pulumi.String("string"),
    			},
    			PowerpackDefinition: &datadog.DashboardV2WidgetPowerpackDefinitionArgs{
    				PowerpackId:            pulumi.String("string"),
    				BackgroundColor:        pulumi.String("string"),
    				BannerImg:              pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				ShowTitle:              pulumi.Bool(false),
    				TemplateVariables: &datadog.DashboardV2WidgetPowerpackDefinitionTemplateVariablesArgs{
    					ControlledByPowerpacks: datadog.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArray{
    						&datadog.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs{
    							Name: pulumi.String("string"),
    							Values: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Prefix: pulumi.String("string"),
    						},
    					},
    					ControlledExternallies: datadog.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledExternallyArray{
    						&datadog.DashboardV2WidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs{
    							Name: pulumi.String("string"),
    							Values: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Prefix: pulumi.String("string"),
    						},
    					},
    				},
    				Time: &datadog.DashboardV2WidgetPowerpackDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetPowerpackDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetPowerpackDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			QueryTableDefinition: &datadog.DashboardV2WidgetQueryTableDefinitionArgs{
    				CustomLinks: datadog.DashboardV2WidgetQueryTableDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetQueryTableDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HasSearchBar:           pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Requests: datadog.DashboardV2WidgetQueryTableDefinitionRequestArray{
    					&datadog.DashboardV2WidgetQueryTableDefinitionRequestArgs{
    						Aggregator: pulumi.String("string"),
    						Alias:      pulumi.String("string"),
    						CellDisplayModes: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						ConditionalFormats: datadog.DashboardV2WidgetQueryTableDefinitionRequestConditionalFormatArray{
    							&datadog.DashboardV2WidgetQueryTableDefinitionRequestConditionalFormatArgs{
    								Comparator:    pulumi.String("string"),
    								Palette:       pulumi.String("string"),
    								Value:         pulumi.Float64(0),
    								CustomBgColor: pulumi.String("string"),
    								CustomFgColor: pulumi.String("string"),
    								HideValue:     pulumi.Bool(false),
    								ImageUrl:      pulumi.String("string"),
    								Metric:        pulumi.String("string"),
    								Timeframe:     pulumi.String("string"),
    							},
    						},
    						Formulas: datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetQueryTableDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Limit: pulumi.Int(0),
    						Order: pulumi.String("string"),
    						Queries: datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetQueryTableDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						TextFormats: datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatArray{
    							&datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatArgs{
    								TextFormats: datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatArray{
    									&datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatArgs{
    										Match: &datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs{
    											Type:  pulumi.String("string"),
    											Value: pulumi.String("string"),
    										},
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Replace: &datadog.DashboardV2WidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs{
    											Type:      pulumi.String("string"),
    											With:      pulumi.String("string"),
    											Substring: pulumi.String("string"),
    										},
    									},
    								},
    							},
    						},
    					},
    				},
    				Time: &datadog.DashboardV2WidgetQueryTableDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetQueryTableDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetQueryTableDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			QueryValueDefinition: &datadog.DashboardV2WidgetQueryValueDefinitionArgs{
    				Autoscale: pulumi.Bool(false),
    				CustomLinks: datadog.DashboardV2WidgetQueryValueDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetQueryValueDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				CustomUnit:             pulumi.String("string"),
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Precision:              pulumi.Int(0),
    				Requests: datadog.DashboardV2WidgetQueryValueDefinitionRequestArray{
    					&datadog.DashboardV2WidgetQueryValueDefinitionRequestArgs{
    						Aggregator: pulumi.String("string"),
    						ConditionalFormats: datadog.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArray{
    							&datadog.DashboardV2WidgetQueryValueDefinitionRequestConditionalFormatArgs{
    								Comparator:    pulumi.String("string"),
    								Palette:       pulumi.String("string"),
    								Value:         pulumi.Float64(0),
    								CustomBgColor: pulumi.String("string"),
    								CustomFgColor: pulumi.String("string"),
    								HideValue:     pulumi.Bool(false),
    								ImageUrl:      pulumi.String("string"),
    								Metric:        pulumi.String("string"),
    								Timeframe:     pulumi.String("string"),
    							},
    						},
    						Formulas: datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaArray{
    							&datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetQueryValueDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryArray{
    							&datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetQueryValueDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    				},
    				TextAlign: pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetQueryValueDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetQueryValueDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetQueryValueDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				TimeseriesBackground: &datadog.DashboardV2WidgetQueryValueDefinitionTimeseriesBackgroundArgs{
    					Type: pulumi.String("string"),
    					Yaxis: &datadog.DashboardV2WidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs{
    						IncludeZero: pulumi.Bool(false),
    						Label:       pulumi.String("string"),
    						Max:         pulumi.String("string"),
    						Min:         pulumi.String("string"),
    						Scale:       pulumi.String("string"),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			RunWorkflowDefinition: &datadog.DashboardV2WidgetRunWorkflowDefinitionArgs{
    				WorkflowId: pulumi.String("string"),
    				CustomLinks: datadog.DashboardV2WidgetRunWorkflowDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetRunWorkflowDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				Inputs: datadog.DashboardV2WidgetRunWorkflowDefinitionInputTypeArray{
    					&datadog.DashboardV2WidgetRunWorkflowDefinitionInputTypeArgs{
    						Name:  pulumi.String("string"),
    						Value: pulumi.String("string"),
    					},
    				},
    				LiveSpan: pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetRunWorkflowDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetRunWorkflowDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetRunWorkflowDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			SankeyDefinition: &datadog.DashboardV2WidgetSankeyDefinitionArgs{
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Requests: datadog.DashboardV2WidgetSankeyDefinitionRequestArray{
    					&datadog.DashboardV2WidgetSankeyDefinitionRequestArgs{
    						NetworkRequest: &datadog.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestArgs{
    							Query: &datadog.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQueryArgs{
    								DataSource: pulumi.String("string"),
    								GroupBies: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								Limit:       pulumi.Int(0),
    								QueryString: pulumi.String("string"),
    								Compute: &datadog.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQueryComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Metric:      pulumi.String("string"),
    								},
    								Mode:                 pulumi.String("string"),
    								ShouldExcludeMissing: pulumi.Bool(false),
    								Sort: &datadog.DashboardV2WidgetSankeyDefinitionRequestNetworkRequestQuerySortArgs{
    									Field: pulumi.String("string"),
    									Order: pulumi.String("string"),
    								},
    							},
    						},
    						RumRequest: &datadog.DashboardV2WidgetSankeyDefinitionRequestRumRequestArgs{
    							Query: &datadog.DashboardV2WidgetSankeyDefinitionRequestRumRequestQueryArgs{
    								DataSource:     pulumi.String("string"),
    								Mode:           pulumi.String("string"),
    								QueryString:    pulumi.String("string"),
    								EntriesPerStep: pulumi.Int(0),
    								NumberOfSteps:  pulumi.Int(0),
    								Source:         pulumi.String("string"),
    								SubqueryId:     pulumi.String("string"),
    								Target:         pulumi.String("string"),
    							},
    						},
    					},
    				},
    				ShowOtherLinks: pulumi.Bool(false),
    				SortNodes:      pulumi.Bool(false),
    				Time: &datadog.DashboardV2WidgetSankeyDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetSankeyDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetSankeyDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			ScatterplotDefinition: &datadog.DashboardV2WidgetScatterplotDefinitionArgs{
    				ColorByGroups: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				CustomLinks: datadog.DashboardV2WidgetScatterplotDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetScatterplotDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Request: &datadog.DashboardV2WidgetScatterplotDefinitionRequestArgs{
    					ScatterplotTables: datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableArray{
    						&datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableArgs{
    							Formulas: datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableFormulaArray{
    								&datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs{
    									Dimension:         pulumi.String("string"),
    									FormulaExpression: pulumi.String("string"),
    									Alias:             pulumi.String("string"),
    								},
    							},
    							Queries: datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryArray{
    								&datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryArgs{
    									ApmDependencyStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs{
    										DataSource:      pulumi.String("string"),
    										Env:             pulumi.String("string"),
    										Name:            pulumi.String("string"),
    										OperationName:   pulumi.String("string"),
    										ResourceName:    pulumi.String("string"),
    										Service:         pulumi.String("string"),
    										Stat:            pulumi.String("string"),
    										CrossOrgUuids:   pulumi.String("string"),
    										IsUpstream:      pulumi.Bool(false),
    										PrimaryTagName:  pulumi.String("string"),
    										PrimaryTagValue: pulumi.String("string"),
    									},
    									ApmResourceStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs{
    										DataSource:    pulumi.String("string"),
    										Env:           pulumi.String("string"),
    										Name:          pulumi.String("string"),
    										Service:       pulumi.String("string"),
    										Stat:          pulumi.String("string"),
    										CrossOrgUuids: pulumi.String("string"),
    										GroupBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										OperationName:   pulumi.String("string"),
    										PrimaryTagName:  pulumi.String("string"),
    										PrimaryTagValue: pulumi.String("string"),
    										ResourceName:    pulumi.String("string"),
    									},
    									CloudCostQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs{
    										DataSource:    pulumi.String("string"),
    										Name:          pulumi.String("string"),
    										Query:         pulumi.String("string"),
    										Aggregator:    pulumi.String("string"),
    										CrossOrgUuids: pulumi.String("string"),
    									},
    									EventQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs{
    										Computes: datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArray{
    											&datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    												Metric:      pulumi.String("string"),
    											},
    										},
    										DataSource:    pulumi.String("string"),
    										Name:          pulumi.String("string"),
    										CrossOrgUuids: pulumi.String("string"),
    										GroupBies: datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArray{
    											&datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    										},
    										GroupByFields: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs{
    											Fields: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    										Indexes: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Search: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs{
    											Query: pulumi.String("string"),
    										},
    										Storage: pulumi.String("string"),
    									},
    									MetricQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs{
    										Name:          pulumi.String("string"),
    										Query:         pulumi.String("string"),
    										Aggregator:    pulumi.String("string"),
    										CrossOrgUuids: pulumi.String("string"),
    										DataSource:    pulumi.String("string"),
    										SemanticMode:  pulumi.String("string"),
    									},
    									ProcessQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs{
    										DataSource:      pulumi.String("string"),
    										Metric:          pulumi.String("string"),
    										Name:            pulumi.String("string"),
    										Aggregator:      pulumi.String("string"),
    										CrossOrgUuids:   pulumi.String("string"),
    										IsNormalizedCpu: pulumi.Bool(false),
    										Limit:           pulumi.Int(0),
    										Sort:            pulumi.String("string"),
    										TagFilters: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										TextFilter: pulumi.String("string"),
    									},
    									SloQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs{
    										DataSource:             pulumi.String("string"),
    										Measure:                pulumi.String("string"),
    										SloId:                  pulumi.String("string"),
    										AdditionalQueryFilters: pulumi.String("string"),
    										CrossOrgUuids:          pulumi.String("string"),
    										GroupMode:              pulumi.String("string"),
    										Name:                   pulumi.String("string"),
    										SloQueryType:           pulumi.String("string"),
    									},
    								},
    							},
    						},
    					},
    					X: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXArgs{
    						Aggregator: pulumi.String("string"),
    						Formulas: datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaArray{
    							&datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryArray{
    							&datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestXQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    					Y: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYArgs{
    						Aggregator: pulumi.String("string"),
    						Formulas: datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaArray{
    							&datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								CellDisplayModeOptions: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs{
    									TrendType: pulumi.String("string"),
    									YScale:    pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaConditionalFormatArray{
    									&datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs{
    											PerUnitName: pulumi.String("string"),
    											UnitName:    pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						Queries: datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryArray{
    							&datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryArgs{
    									Computes: datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryComputeArray{
    										&datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArray{
    										&datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									GroupByFields: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsArgs{
    										Fields: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit: pulumi.Int(0),
    										Sort: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQueryGroupByFieldsSortArgs{
    											Aggregation: pulumi.String("string"),
    											Metric:      pulumi.String("string"),
    											Order:       pulumi.String("string"),
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    									SemanticMode:  pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.DashboardV2WidgetScatterplotDefinitionRequestYQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    					},
    				},
    				Time: &datadog.DashboardV2WidgetScatterplotDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetScatterplotDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetScatterplotDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Xaxis: &datadog.DashboardV2WidgetScatterplotDefinitionXaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    				Yaxis: &datadog.DashboardV2WidgetScatterplotDefinitionYaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    			},
    			ServiceLevelObjectiveDefinition: &datadog.DashboardV2WidgetServiceLevelObjectiveDefinitionArgs{
    				SloId:    pulumi.String("string"),
    				ViewType: pulumi.String("string"),
    				ViewMode: pulumi.String("string"),
    				TimeWindows: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				HideIncompleteCostData: pulumi.Bool(false),
    				ShowErrorBudget:        pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetServiceLevelObjectiveDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				AdditionalQueryFilters: pulumi.String("string"),
    				Title:                  pulumi.String("string"),
    				TitleAlign:             pulumi.String("string"),
    				TitleSize:              pulumi.String("string"),
    				GlobalTimeTarget:       pulumi.String("string"),
    				Description:            pulumi.String("string"),
    			},
    			ServicemapDefinition: &datadog.DashboardV2WidgetServicemapDefinitionArgs{
    				Filters: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Service: pulumi.String("string"),
    				CustomLinks: datadog.DashboardV2WidgetServicemapDefinitionCustomLinkArray{
    					&datadog.DashboardV2WidgetServicemapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetServicemapDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetServicemapDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetServicemapDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			SloListDefinition: &datadog.DashboardV2WidgetSloListDefinitionArgs{
    				Requests: datadog.DashboardV2WidgetSloListDefinitionRequestArray{
    					&datadog.DashboardV2WidgetSloListDefinitionRequestArgs{
    						Query: &datadog.DashboardV2WidgetSloListDefinitionRequestQueryArgs{
    							QueryString: pulumi.String("string"),
    							Limit:       pulumi.Int(0),
    							Sorts: datadog.DashboardV2WidgetSloListDefinitionRequestQuerySortArray{
    								&datadog.DashboardV2WidgetSloListDefinitionRequestQuerySortArgs{
    									Column: pulumi.String("string"),
    									Order:  pulumi.String("string"),
    								},
    							},
    						},
    						RequestType: pulumi.String("string"),
    					},
    				},
    				Description:            pulumi.String("string"),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				Time: &datadog.DashboardV2WidgetSloListDefinitionTimeArgs{
    					Fixed: &datadog.DashboardV2WidgetSloListDefinitionTimeFixedArgs{
    						From: pulumi.Int(0),
    						To:   pulumi.Int(0),
    					},
    					Live: &datadog.DashboardV2WidgetSloListDefinitionTimeLiveArgs{
    						Unit:  pulumi.String("string"),
    						Value: pulumi.Int(0),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			SplitGraphDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionArgs{
    				Size: pulumi.String("string"),
    				SplitConfig: &datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigArgs{
    					Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigSortArgs{
    						Order: pulumi.String("string"),
    						Compute: &datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigSortComputeArgs{
    							Metric:      pulumi.String("string"),
    							Aggregation: pulumi.String("string"),
    						},
    					},
    					SplitDimensions: datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigSplitDimensionArray{
    						&datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigSplitDimensionArgs{
    							OneGraphPer: pulumi.String("string"),
    						},
    					},
    					Limit: pulumi.Int(0),
    					StaticSplits: datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitArray{
    						&datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitArgs{
    							SplitVectors: datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArray{
    								&datadog.DashboardV2WidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArgs{
    									TagKey: pulumi.String("string"),
    									TagValues: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    								},
    							},
    						},
    					},
    				},
    				Description:            pulumi.String("string"),
    				HasUniformYAxes:        pulumi.Bool(false),
    				HideIncompleteCostData: pulumi.Bool(false),
    				LiveSpan:               pulumi.String("string"),
    				SourceWidgetDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionArgs{
    					ChangeDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionArgs{
    						CustomLinks: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionCustomLinkArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionCustomLinkArgs{
    								IsHidden:      pulumi.Bool(false),
    								Label:         pulumi.String("string"),
    								Link:          pulumi.String("string"),
    								OverrideLabel: pulumi.String("string"),
    							},
    						},
    						Description:            pulumi.String("string"),
    						HideIncompleteCostData: pulumi.Bool(false),
    						LiveSpan:               pulumi.String("string"),
    						Requests: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestArgs{
    								ChangeType: pulumi.String("string"),
    								CompareTo:  pulumi.String("string"),
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								IncreaseGood: pulumi.Bool(false),
    								OrderBy:      pulumi.String("string"),
    								OrderDir:     pulumi.String("string"),
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    								ShowPresent: pulumi.Bool(false),
    							},
    						},
    						Time: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeArgs{
    							Fixed: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeFixedArgs{
    								From: pulumi.Int(0),
    								To:   pulumi.Int(0),
    							},
    							Live: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionTimeLiveArgs{
    								Unit:  pulumi.String("string"),
    								Value: pulumi.Int(0),
    							},
    						},
    						Title:      pulumi.String("string"),
    						TitleAlign: pulumi.String("string"),
    						TitleSize:  pulumi.String("string"),
    					},
    					GeomapDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionArgs{
    						CustomLinks: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionCustomLinkArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionCustomLinkArgs{
    								IsHidden:      pulumi.Bool(false),
    								Label:         pulumi.String("string"),
    								Link:          pulumi.String("string"),
    								OverrideLabel: pulumi.String("string"),
    							},
    						},
    						Description:            pulumi.String("string"),
    						HideIncompleteCostData: pulumi.Bool(false),
    						LiveSpan:               pulumi.String("string"),
    						Requests: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestArgs{
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    							},
    						},
    						Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionStyleArgs{
    							Palette:     pulumi.String("string"),
    							PaletteFlip: pulumi.Bool(false),
    						},
    						Time: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeArgs{
    							Fixed: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeFixedArgs{
    								From: pulumi.Int(0),
    								To:   pulumi.Int(0),
    							},
    							Live: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionTimeLiveArgs{
    								Unit:  pulumi.String("string"),
    								Value: pulumi.Int(0),
    							},
    						},
    						Title:      pulumi.String("string"),
    						TitleAlign: pulumi.String("string"),
    						TitleSize:  pulumi.String("string"),
    						View: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionViewArgs{
    							Focus: pulumi.String("string"),
    						},
    					},
    					QueryTableDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionArgs{
    						CustomLinks: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionCustomLinkArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionCustomLinkArgs{
    								IsHidden:      pulumi.Bool(false),
    								Label:         pulumi.String("string"),
    								Link:          pulumi.String("string"),
    								OverrideLabel: pulumi.String("string"),
    							},
    						},
    						Description:            pulumi.String("string"),
    						HasSearchBar:           pulumi.String("string"),
    						HideIncompleteCostData: pulumi.Bool(false),
    						LiveSpan:               pulumi.String("string"),
    						Requests: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestArgs{
    								Aggregator: pulumi.String("string"),
    								Alias:      pulumi.String("string"),
    								CellDisplayModes: pulumi.StringArray{
    									pulumi.String("string"),
    								},
    								ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Limit: pulumi.Int(0),
    								Order: pulumi.String("string"),
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    								TextFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatArgs{
    										TextFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatArgs{
    												Match: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatMatchArgs{
    													Type:  pulumi.String("string"),
    													Value: pulumi.String("string"),
    												},
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Replace: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs{
    													Type:      pulumi.String("string"),
    													With:      pulumi.String("string"),
    													Substring: pulumi.String("string"),
    												},
    											},
    										},
    									},
    								},
    							},
    						},
    						Time: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeArgs{
    							Fixed: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeFixedArgs{
    								From: pulumi.Int(0),
    								To:   pulumi.Int(0),
    							},
    							Live: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionTimeLiveArgs{
    								Unit:  pulumi.String("string"),
    								Value: pulumi.Int(0),
    							},
    						},
    						Title:      pulumi.String("string"),
    						TitleAlign: pulumi.String("string"),
    						TitleSize:  pulumi.String("string"),
    					},
    					QueryValueDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionArgs{
    						Autoscale: pulumi.Bool(false),
    						CustomLinks: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionCustomLinkArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionCustomLinkArgs{
    								IsHidden:      pulumi.Bool(false),
    								Label:         pulumi.String("string"),
    								Link:          pulumi.String("string"),
    								OverrideLabel: pulumi.String("string"),
    							},
    						},
    						CustomUnit:             pulumi.String("string"),
    						Description:            pulumi.String("string"),
    						HideIncompleteCostData: pulumi.Bool(false),
    						LiveSpan:               pulumi.String("string"),
    						Precision:              pulumi.Int(0),
    						Requests: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestArgs{
    								Aggregator: pulumi.String("string"),
    								ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestConditionalFormatArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionRequestQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    							},
    						},
    						TextAlign: pulumi.String("string"),
    						Time: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeArgs{
    							Fixed: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeFixedArgs{
    								From: pulumi.Int(0),
    								To:   pulumi.Int(0),
    							},
    							Live: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeLiveArgs{
    								Unit:  pulumi.String("string"),
    								Value: pulumi.Int(0),
    							},
    						},
    						TimeseriesBackground: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeseriesBackgroundArgs{
    							Type: pulumi.String("string"),
    							Yaxis: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionQueryValueDefinitionTimeseriesBackgroundYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						Title:      pulumi.String("string"),
    						TitleAlign: pulumi.String("string"),
    						TitleSize:  pulumi.String("string"),
    					},
    					ScatterplotDefinition: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionArgs{
    						ColorByGroups: pulumi.StringArray{
    							pulumi.String("string"),
    						},
    						CustomLinks: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionCustomLinkArray{
    							&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionCustomLinkArgs{
    								IsHidden:      pulumi.Bool(false),
    								Label:         pulumi.String("string"),
    								Link:          pulumi.String("string"),
    								OverrideLabel: pulumi.String("string"),
    							},
    						},
    						Description:            pulumi.String("string"),
    						HideIncompleteCostData: pulumi.Bool(false),
    						LiveSpan:               pulumi.String("string"),
    						Request: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestArgs{
    							ScatterplotTables: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableArray{
    								&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableArgs{
    									Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableFormulaArray{
    										&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableFormulaArgs{
    											Dimension:         pulumi.String("string"),
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    										},
    									},
    									Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryArray{
    										&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Env:             pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												OperationName:   pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    												Service:         pulumi.String("string"),
    												Stat:            pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsUpstream:      pulumi.Bool(false),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    											},
    											ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Env:           pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Service:       pulumi.String("string"),
    												Stat:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												OperationName:   pulumi.String("string"),
    												PrimaryTagName:  pulumi.String("string"),
    												PrimaryTagValue: pulumi.String("string"),
    												ResourceName:    pulumi.String("string"),
    											},
    											CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs{
    												Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArray{
    													&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    														Metric:      pulumi.String("string"),
    													},
    												},
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArray{
    													&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsArgs{
    													Fields: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByFieldsSortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    												SemanticMode:  pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs{
    												DataSource:      pulumi.String("string"),
    												Metric:          pulumi.String("string"),
    												Name:            pulumi.String("string"),
    												Aggregator:      pulumi.String("string"),
    												CrossOrgUuids:   pulumi.String("string"),
    												IsNormalizedCpu: pulumi.Bool(false),
    												Limit:           pulumi.Int(0),
    												Sort:            pulumi.String("string"),
    												TagFilters: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												TextFilter: pulumi.String("string"),
    											},
    											SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs{
    												DataSource:             pulumi.String("string"),
    												Measure:                pulumi.String("string"),
    												SloId:                  pulumi.String("string"),
    												AdditionalQueryFilters: pulumi.String("string"),
    												CrossOrgUuids:          pulumi.String("string"),
    												GroupMode:              pulumi.String("string"),
    												Name:                   pulumi.String("string"),
    												SloQueryType:           pulumi.String("string"),
    											},
    										},
    									},
    								},
    							},
    							X: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXArgs{
    								Aggregator: pulumi.String("string"),
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryApmDependencyStatsQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Env:             pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											OperationName:   pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    											Service:         pulumi.String("string"),
    											Stat:            pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsUpstream:      pulumi.Bool(false),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    										},
    										ApmResourceStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryApmResourceStatsQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Env:           pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Service:       pulumi.String("string"),
    											Stat:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											OperationName:   pulumi.String("string"),
    											PrimaryTagName:  pulumi.String("string"),
    											PrimaryTagValue: pulumi.String("string"),
    											ResourceName:    pulumi.String("string"),
    										},
    										CloudCostQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryCloudCostQueryArgs{
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    										},
    										EventQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryArgs{
    											Computes: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryComputeArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    													Metric:      pulumi.String("string"),
    												},
    											},
    											DataSource:    pulumi.String("string"),
    											Name:          pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											GroupBies: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByArray{
    												&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupBySortArgs{
    														Aggregation: pulumi.String("string"),
    														Metric:      pulumi.String("string"),
    														Order:       pulumi.String("string"),
    													},
    												},
    											},
    											GroupByFields: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsArgs{
    												Fields: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit: pulumi.Int(0),
    												Sort: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQueryGroupByFieldsSortArgs{
    													Aggregation: pulumi.String("string"),
    													Metric:      pulumi.String("string"),
    													Order:       pulumi.String("string"),
    												},
    											},
    											Indexes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Search: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryEventQuerySearchArgs{
    												Query: pulumi.String("string"),
    											},
    											Storage: pulumi.String("string"),
    										},
    										MetricQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryMetricQueryArgs{
    											Name:          pulumi.String("string"),
    											Query:         pulumi.String("string"),
    											Aggregator:    pulumi.String("string"),
    											CrossOrgUuids: pulumi.String("string"),
    											DataSource:    pulumi.String("string"),
    											SemanticMode:  pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQueryProcessQueryArgs{
    											DataSource:      pulumi.String("string"),
    											Metric:          pulumi.String("string"),
    											Name:            pulumi.String("string"),
    											Aggregator:      pulumi.String("string"),
    											CrossOrgUuids:   pulumi.String("string"),
    											IsNormalizedCpu: pulumi.Bool(false),
    											Limit:           pulumi.Int(0),
    											Sort:            pulumi.String("string"),
    											TagFilters: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											TextFilter: pulumi.String("string"),
    										},
    										SloQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestXQuerySloQueryArgs{
    											DataSource:             pulumi.String("string"),
    											Measure:                pulumi.String("string"),
    											SloId:                  pulumi.String("string"),
    											AdditionalQueryFilters: pulumi.String("string"),
    											CrossOrgUuids:          pulumi.String("string"),
    											GroupMode:              pulumi.String("string"),
    											Name:                   pulumi.String("string"),
    											SloQueryType:           pulumi.String("string"),
    										},
    									},
    								},
    							},
    							Y: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYArgs{
    								Aggregator: pulumi.String("string"),
    								Formulas: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaArgs{
    										FormulaExpression: pulumi.String("string"),
    										Alias:             pulumi.String("string"),
    										CellDisplayMode:   pulumi.String("string"),
    										CellDisplayModeOptions: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaCellDisplayModeOptionsArgs{
    											TrendType: pulumi.String("string"),
    											YScale:    pulumi.String("string"),
    										},
    										ConditionalFormats: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaConditionalFormatArray{
    											&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaConditionalFormatArgs{
    												Comparator:    pulumi.String("string"),
    												Palette:       pulumi.String("string"),
    												Value:         pulumi.Float64(0),
    												CustomBgColor: pulumi.String("string"),
    												CustomFgColor: pulumi.String("string"),
    												HideValue:     pulumi.Bool(false),
    												ImageUrl:      pulumi.String("string"),
    												Metric:        pulumi.String("string"),
    												Timeframe:     pulumi.String("string"),
    											},
    										},
    										Limit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaLimitArgs{
    											Count: pulumi.Int(0),
    											Order: pulumi.String("string"),
    										},
    										NumberFormat: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatArgs{
    											Unit: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitArgs{
    												Canonical: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitCanonicalArgs{
    													PerUnitName: pulumi.String("string"),
    													UnitName:    pulumi.String("string"),
    												},
    												Custom: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitCustomArgs{
    													Label: pulumi.String("string"),
    												},
    											},
    											UnitScale: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaNumberFormatUnitScaleArgs{
    												UnitName: pulumi.String("string"),
    											},
    										},
    										Style: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYFormulaStyleArgs{
    											Palette:      pulumi.String("string"),
    											PaletteIndex: pulumi.Int(0),
    										},
    									},
    								},
    								Queries: datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryArray{
    									&datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryArgs{
    										ApmDependencyStatsQuery: &datadog.DashboardV2WidgetSplitGraphDefinitionSourceWidgetDefinitionScatterplotDefinitionRequestYQueryApmDependencyStatsQueryArgs{
    </