1. Packages
  2. Datadog Provider
  3. API Docs
  4. Dashboard
Datadog v4.51.0 published on Wednesday, Jun 11, 2025 by Pulumi

datadog.Dashboard

Explore with Pulumi AI

datadog logo
Datadog v4.51.0 published on Wednesday, Jun 11, 2025 by Pulumi

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

    !> The is_read_only field is deprecated and non-functional. Use restricted_roles instead to define which roles are required to edit the dashboard.

    Example Usage

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

    Create Dashboard Resource

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

    Constructor syntax

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

    Parameters

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

    Constructor example

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

    var dashboardResource = new Datadog.Dashboard("dashboardResource", new()
    {
        LayoutType = "string",
        Title = "string",
        RestrictedRoles = new[]
        {
            "string",
        },
        NotifyLists = new[]
        {
            "string",
        },
        ReflowType = "string",
        DashboardLists = new[]
        {
            0,
        },
        Tags = new[]
        {
            "string",
        },
        TemplateVariablePresets = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariablePresetArgs
            {
                Name = "string",
                TemplateVariables = new[]
                {
                    new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                    {
                        Name = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        TemplateVariables = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariableArgs
            {
                Name = "string",
                AvailableValues = new[]
                {
                    "string",
                },
                Defaults = new[]
                {
                    "string",
                },
                Prefix = "string",
            },
        },
        Description = "string",
        Url = "string",
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "string",
                    VizType = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                {
                    AlertId = "string",
                    Precision = 0,
                    TextAlign = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Unit = "string",
                },
                ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ChangeType = "string",
                            CompareTo = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            IncreaseGood = false,
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OrderBy = "string",
                            OrderDir = "string",
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ShowPresent = false,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetCheckStatusDefinitionArgs
                {
                    Check = "string",
                    Grouping = "string",
                    Group = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    Tags = new[]
                    {
                        "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                DistributionDefinition = new Datadog.Inputs.DashboardWidgetDistributionDefinitionArgs
                {
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.DashboardWidgetDistributionDefinitionXaxisArgs
                    {
                        IncludeZero = false,
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    Yaxis = new Datadog.Inputs.DashboardWidgetDistributionDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                EventStreamDefinition = new Datadog.Inputs.DashboardWidgetEventStreamDefinitionArgs
                {
                    Query = "string",
                    EventSize = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetEventTimelineDefinitionArgs
                {
                    Query = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FreeTextDefinition = new Datadog.Inputs.DashboardWidgetFreeTextDefinitionArgs
                {
                    Text = "string",
                    Color = "string",
                    FontSize = "string",
                    TextAlign = "string",
                },
                GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                {
                    View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                    {
                        Focus = "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                    {
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                GroupDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionArgs
                {
                    LayoutType = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    ShowTitle = false,
                    Title = "string",
                    Widgets = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetArgs
                        {
                            AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                            {
                                AlertId = "string",
                                VizType = "string",
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                            {
                                AlertId = "string",
                                Precision = 0,
                                TextAlign = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Unit = "string",
                            },
                            ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ChangeType = "string",
                                        CompareTo = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        IncreaseGood = false,
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        OrderBy = "string",
                                        OrderDir = "string",
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ShowPresent = false,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetCheckStatusDefinitionArgs
                            {
                                Check = "string",
                                Grouping = "string",
                                Group = "string",
                                GroupBies = new[]
                                {
                                    "string",
                                },
                                LiveSpan = "string",
                                Tags = new[]
                                {
                                    "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            DistributionDefinition = new Datadog.Inputs.DashboardWidgetDistributionDefinitionArgs
                            {
                                LegendSize = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ApmStatsQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs
                                        {
                                            Env = "string",
                                            Name = "string",
                                            PrimaryTag = "string",
                                            RowType = "string",
                                            Service = "string",
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                                {
                                                    Name = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Resource = "string",
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardWidgetDistributionDefinitionXaxisArgs
                                {
                                    IncludeZero = false,
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                Yaxis = new Datadog.Inputs.DashboardWidgetDistributionDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            EventStreamDefinition = new Datadog.Inputs.DashboardWidgetEventStreamDefinitionArgs
                            {
                                Query = "string",
                                EventSize = "string",
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetEventTimelineDefinitionArgs
                            {
                                Query = "string",
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            FreeTextDefinition = new Datadog.Inputs.DashboardWidgetFreeTextDefinitionArgs
                            {
                                Text = "string",
                                Color = "string",
                                FontSize = "string",
                                TextAlign = "string",
                            },
                            GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                            {
                                View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                                {
                                    Focus = "string",
                                },
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    CrossOrgUuids = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                                {
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            HeatmapDefinition = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetHeatmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Events = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetHeatmapDefinitionEventArgs
                                    {
                                        Q = "string",
                                        TagsExecution = "string",
                                    },
                                },
                                LegendSize = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Yaxis = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            HostmapDefinition = new Datadog.Inputs.DashboardWidgetHostmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetHostmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Groups = new[]
                                {
                                    "string",
                                },
                                NoGroupHosts = false,
                                NoMetricHosts = false,
                                NodeType = "string",
                                Request = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestArgs
                                {
                                    Fills = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestFillArgs
                                        {
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestFillProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                    Sizes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestSizeArgs
                                        {
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestSizeProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                },
                                Scopes = new[]
                                {
                                    "string",
                                },
                                Style = new Datadog.Inputs.DashboardWidgetHostmapDefinitionStyleArgs
                                {
                                    FillMax = "string",
                                    FillMin = "string",
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            Id = 0,
                            IframeDefinition = new Datadog.Inputs.DashboardWidgetIframeDefinitionArgs
                            {
                                Url = "string",
                            },
                            ImageDefinition = new Datadog.Inputs.DashboardWidgetImageDefinitionArgs
                            {
                                Url = "string",
                                HasBackground = false,
                                HasBorder = false,
                                HorizontalAlign = "string",
                                Margin = "string",
                                Sizing = "string",
                                UrlDarkTheme = "string",
                                VerticalAlign = "string",
                            },
                            ListStreamDefinition = new Datadog.Inputs.DashboardWidgetListStreamDefinitionArgs
                            {
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestArgs
                                    {
                                        Columns = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestColumnArgs
                                            {
                                                Field = "string",
                                                Width = "string",
                                            },
                                        },
                                        Query = new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQueryArgs
                                        {
                                            DataSource = "string",
                                            ClusteringPatternFieldPath = "string",
                                            EventSize = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            QueryString = "string",
                                            Sort = new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQuerySortArgs
                                            {
                                                Column = "string",
                                                Order = "string",
                                            },
                                            Storage = "string",
                                        },
                                        ResponseFormat = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            LogStreamDefinition = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionArgs
                            {
                                Columns = new[]
                                {
                                    "string",
                                },
                                Indexes = new[]
                                {
                                    "string",
                                },
                                LiveSpan = "string",
                                MessageDisplay = "string",
                                Query = "string",
                                ShowDateColumn = false,
                                ShowMessageColumn = false,
                                Sort = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionSortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ManageStatusDefinition = new Datadog.Inputs.DashboardWidgetManageStatusDefinitionArgs
                            {
                                Query = "string",
                                ColorPreference = "string",
                                DisplayFormat = "string",
                                HideZeroCounts = false,
                                ShowLastTriggered = false,
                                ShowPriority = false,
                                Sort = "string",
                                SummaryType = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            NoteDefinition = new Datadog.Inputs.DashboardWidgetNoteDefinitionArgs
                            {
                                Content = "string",
                                BackgroundColor = "string",
                                FontSize = "string",
                                HasPadding = false,
                                ShowTick = false,
                                TextAlign = "string",
                                TickEdge = "string",
                                TickPos = "string",
                                VerticalAlign = "string",
                            },
                            PowerpackDefinition = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionArgs
                            {
                                PowerpackId = "string",
                                BackgroundColor = "string",
                                BannerImg = "string",
                                ShowTitle = false,
                                TemplateVariables = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs
                                {
                                    ControlledByPowerpacks = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs
                                        {
                                            Name = "string",
                                            Values = new[]
                                            {
                                                "string",
                                            },
                                            Prefix = "string",
                                        },
                                    },
                                    ControlledExternallies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs
                                        {
                                            Name = "string",
                                            Values = new[]
                                            {
                                                "string",
                                            },
                                            Prefix = "string",
                                        },
                                    },
                                },
                                Title = "string",
                            },
                            QueryTableDefinition = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                HasSearchBar = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        Alias = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ApmStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                                        {
                                            Env = "string",
                                            Name = "string",
                                            PrimaryTag = "string",
                                            RowType = "string",
                                            Service = "string",
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                                {
                                                    Name = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Resource = "string",
                                        },
                                        CellDisplayModes = new[]
                                        {
                                            "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                CellDisplayModeOptions = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                {
                                                    TrendType = "string",
                                                    YScale = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Limit = 0,
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Order = "string",
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        TextFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs
                                            {
                                                TextFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                                    {
                                                        Match = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                                        {
                                                            Type = "string",
                                                            Value = "string",
                                                        },
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        Palette = "string",
                                                        Replace = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                                        {
                                                            Type = "string",
                                                            With = "string",
                                                            Substring = "string",
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            QueryValueDefinition = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionArgs
                            {
                                Autoscale = false,
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                CustomUnit = "string",
                                LiveSpan = "string",
                                Precision = 0,
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        AuditQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                TextAlign = "string",
                                TimeseriesBackground = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                                {
                                    Type = "string",
                                    Yaxis = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                    {
                                        IncludeZero = false,
                                        Label = "string",
                                        Max = "string",
                                        Min = "string",
                                        Scale = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            RunWorkflowDefinition = new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionArgs
                            {
                                WorkflowId = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Inputs = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionInputArgs
                                    {
                                        Name = "string",
                                        Value = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionArgs
                            {
                                ColorByGroups = new[]
                                {
                                    "string",
                                },
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Request = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestArgs
                                {
                                    ScatterplotTables = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs
                                        {
                                            Formulas = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                                {
                                                    Dimension = "string",
                                                    FormulaExpression = "string",
                                                    Alias = "string",
                                                },
                                            },
                                            Queries = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                                {
                                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                    {
                                                        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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                    {
                                                        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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                    },
                                                    EventQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                    {
                                                        Computes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Interval = 0,
                                                                Metric = "string",
                                                            },
                                                        },
                                                        DataSource = "string",
                                                        Name = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                Sort = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Metric = "string",
                                                                    Order = "string",
                                                                },
                                                            },
                                                        },
                                                        Indexes = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Search = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                        {
                                                            Query = "string",
                                                        },
                                                        Storage = "string",
                                                    },
                                                    MetricQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                    {
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        CrossOrgUuids = "string",
                                                        DataSource = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                    {
                                                        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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Measure = "string",
                                                        SloId = "string",
                                                        AdditionalQueryFilters = "string",
                                                        CrossOrgUuids = "string",
                                                        GroupMode = "string",
                                                        Name = "string",
                                                        SloQueryType = "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                    Xes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXArgs
                                        {
                                            Aggregator = "string",
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                    Ys = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYArgs
                                        {
                                            Aggregator = "string",
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionXaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                Yaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardWidgetServiceLevelObjectiveDefinitionArgs
                            {
                                SloId = "string",
                                TimeWindows = new[]
                                {
                                    "string",
                                },
                                ViewMode = "string",
                                ViewType = "string",
                                AdditionalQueryFilters = "string",
                                GlobalTimeTarget = "string",
                                ShowErrorBudget = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ServicemapDefinition = new Datadog.Inputs.DashboardWidgetServicemapDefinitionArgs
                            {
                                Filters = new[]
                                {
                                    "string",
                                },
                                Service = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetServicemapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SloListDefinition = new Datadog.Inputs.DashboardWidgetSloListDefinitionArgs
                            {
                                Request = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestArgs
                                {
                                    Query = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestQueryArgs
                                    {
                                        QueryString = "string",
                                        Limit = 0,
                                        Sort = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestQuerySortArgs
                                        {
                                            Column = "string",
                                            Order = "string",
                                        },
                                    },
                                    RequestType = "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SplitGraphDefinition = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionArgs
                            {
                                Size = "string",
                                SourceWidgetDefinition = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSourceWidgetDefinitionArgs
                                {
                                    ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                                            {
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ChangeType = "string",
                                                CompareTo = "string",
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                IncreaseGood = false,
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                OrderBy = "string",
                                                OrderDir = "string",
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            OperationName = "string",
                                                            ResourceName = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            CrossOrgUuids = "string",
                                                            IsUpstream = false,
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                        },
                                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ShowPresent = false,
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                                    {
                                        View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                                        {
                                            Focus = "string",
                                        },
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                                            {
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            OperationName = "string",
                                                            ResourceName = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            CrossOrgUuids = "string",
                                                            IsUpstream = false,
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                        },
                                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                                        {
                                            Palette = "string",
                                            PaletteFlip = false,
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    QueryTableDefinition = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        HasSearchBar = "string",
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestArgs
                                            {
                                                Aggregator = "string",
                                                Alias = "string",
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ApmStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                                                {
                                                    Env = "string",
                                                    Name = "string",
                                                    PrimaryTag = "string",
                                                    RowType = "string",
                                                    Service = "string",
                                                    Columns = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                                        {
                                                            Name = "string",
                                                            Alias = "string",
                                                            CellDisplayMode = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                    Resource = "string",
                                                },
                                                CellDisplayModes = new[]
                                                {
                                                    "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        CellDisplayModeOptions = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                                        {
                                                            TrendType = "string",
                                                            YScale = "string",
                                                        },
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                Limit = 0,
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Order = "string",
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                TextFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs
                                                    {
                                                        TextFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                                            {
                                                                Match = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                                                {
                                                                    Type = "string",
                                                                    Value = "string",
                                                                },
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                Palette = "string",
                                                                Replace = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                                                {
                                                                    Type = "string",
                                                                    With = "string",
                                                                    Substring = "string",
                                                                },
                                                            },
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    QueryValueDefinition = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionArgs
                                    {
                                        Autoscale = false,
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        CustomUnit = "string",
                                        LiveSpan = "string",
                                        Precision = 0,
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestArgs
                                            {
                                                Aggregator = "string",
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                AuditQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                            },
                                        },
                                        TextAlign = "string",
                                        TimeseriesBackground = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                                        {
                                            Type = "string",
                                            Yaxis = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                            {
                                                IncludeZero = false,
                                                Label = "string",
                                                Max = "string",
                                                Min = "string",
                                                Scale = "string",
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionArgs
                                    {
                                        ColorByGroups = new[]
                                        {
                                            "string",
                                        },
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Request = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestArgs
                                        {
                                            ScatterplotTables = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs
                                                {
                                                    Formulas = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                                        {
                                                            Dimension = "string",
                                                            FormulaExpression = "string",
                                                            Alias = "string",
                                                        },
                                                    },
                                                    Queries = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                                        {
                                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                            {
                                                                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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                            {
                                                                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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                            {
                                                                DataSource = "string",
                                                                Name = "string",
                                                                Query = "string",
                                                                Aggregator = "string",
                                                                CrossOrgUuids = "string",
                                                            },
                                                            EventQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                            {
                                                                Computes = new[]
                                                                {
                                                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Interval = 0,
                                                                        Metric = "string",
                                                                    },
                                                                },
                                                                DataSource = "string",
                                                                Name = "string",
                                                                CrossOrgUuids = "string",
                                                                GroupBies = new[]
                                                                {
                                                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                                    {
                                                                        Facet = "string",
                                                                        Limit = 0,
                                                                        Sort = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                                        {
                                                                            Aggregation = "string",
                                                                            Metric = "string",
                                                                            Order = "string",
                                                                        },
                                                                    },
                                                                },
                                                                Indexes = new[]
                                                                {
                                                                    "string",
                                                                },
                                                                Search = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                                {
                                                                    Query = "string",
                                                                },
                                                                Storage = "string",
                                                            },
                                                            MetricQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                            {
                                                                Name = "string",
                                                                Query = "string",
                                                                Aggregator = "string",
                                                                CrossOrgUuids = "string",
                                                                DataSource = "string",
                                                            },
                                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                            {
                                                                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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                            {
                                                                DataSource = "string",
                                                                Measure = "string",
                                                                SloId = "string",
                                                                AdditionalQueryFilters = "string",
                                                                CrossOrgUuids = "string",
                                                                GroupMode = "string",
                                                                Name = "string",
                                                                SloQueryType = "string",
                                                            },
                                                        },
                                                    },
                                                },
                                            },
                                            Xes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXArgs
                                                {
                                                    Aggregator = "string",
                                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                                    {
                                                        Metric = "string",
                                                        FilterBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        SearchBy = "string",
                                                    },
                                                    Q = "string",
                                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                },
                                            },
                                            Ys = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYArgs
                                                {
                                                    Aggregator = "string",
                                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                                    {
                                                        Metric = "string",
                                                        FilterBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Limit = 0,
                                                        SearchBy = "string",
                                                    },
                                                    Q = "string",
                                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                    {
                                                        Index = "string",
                                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Order = "string",
                                                                    Facet = "string",
                                                                },
                                                            },
                                                        },
                                                        MultiComputes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Facet = "string",
                                                                Interval = 0,
                                                            },
                                                        },
                                                        SearchQuery = "string",
                                                    },
                                                },
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                        Xaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionXaxisArgs
                                        {
                                            IncludeZero = false,
                                            Label = "string",
                                            Max = "string",
                                            Min = "string",
                                            Scale = "string",
                                        },
                                        Yaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionYaxisArgs
                                        {
                                            IncludeZero = false,
                                            Label = "string",
                                            Max = "string",
                                            Min = "string",
                                            Scale = "string",
                                        },
                                    },
                                    SunburstDefinition = new Datadog.Inputs.DashboardWidgetSunburstDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        HideTotal = false,
                                        LegendInline = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendInlineArgs
                                        {
                                            Type = "string",
                                            HidePercent = false,
                                            HideValue = false,
                                        },
                                        LegendTable = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendTableArgs
                                        {
                                            Type = "string",
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestArgs
                                            {
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                AuditQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                NetworkQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestStyleArgs
                                                {
                                                    Palette = "string",
                                                },
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        Events = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                                            {
                                                Q = "string",
                                                TagsExecution = "string",
                                            },
                                        },
                                        LegendColumns = new[]
                                        {
                                            "string",
                                        },
                                        LegendLayout = "string",
                                        LegendSize = "string",
                                        LiveSpan = "string",
                                        Markers = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                                            {
                                                Value = "string",
                                                DisplayType = "string",
                                                Label = "string",
                                            },
                                        },
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                                            {
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                AuditQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                DisplayType = "string",
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Metadatas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs
                                                    {
                                                        Expression = "string",
                                                        AliasName = "string",
                                                    },
                                                },
                                                NetworkQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                OnRightYaxis = false,
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestStyleArgs
                                                {
                                                    LineType = "string",
                                                    LineWidth = "string",
                                                    Palette = "string",
                                                },
                                            },
                                        },
                                        RightYaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRightYaxisArgs
                                        {
                                            IncludeZero = false,
                                            Label = "string",
                                            Max = "string",
                                            Min = "string",
                                            Scale = "string",
                                        },
                                        ShowLegend = false,
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                        Yaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs
                                        {
                                            IncludeZero = false,
                                            Label = "string",
                                            Max = "string",
                                            Min = "string",
                                            Scale = "string",
                                        },
                                    },
                                    ToplistDefinition = new Datadog.Inputs.DashboardWidgetToplistDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestArgs
                                            {
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                AuditQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetToplistDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestStyleArgs
                                                {
                                                    Palette = "string",
                                                },
                                            },
                                        },
                                        Styles = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleArgs
                                            {
                                                Displays = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleDisplayArgs
                                                    {
                                                        Type = "string",
                                                    },
                                                },
                                                Palette = "string",
                                                Scaling = "string",
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    TreemapDefinition = new Datadog.Inputs.DashboardWidgetTreemapDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestArgs
                                            {
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        NumberFormat = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                                        {
                                                            Unit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                                            {
                                                                Canonical = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                                {
                                                                    UnitName = "string",
                                                                    PerUnitName = "string",
                                                                },
                                                                Custom = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                                {
                                                                    Label = "string",
                                                                },
                                                            },
                                                            UnitScale = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                            {
                                                                UnitName = "string",
                                                            },
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            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.DashboardWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            CrossOrgUuids = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            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.DashboardWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            CrossOrgUuids = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                            },
                                        },
                                        Title = "string",
                                    },
                                },
                                SplitConfig = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigArgs
                                {
                                    Sort = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSortArgs
                                    {
                                        Order = "string",
                                        Compute = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSortComputeArgs
                                        {
                                            Metric = "string",
                                            Aggregation = "string",
                                        },
                                    },
                                    SplitDimensions = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSplitDimensionsArgs
                                    {
                                        OneGraphPer = "string",
                                    },
                                    Limit = 0,
                                    StaticSplits = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitArgs
                                        {
                                            SplitVectors = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArgs
                                                {
                                                    TagKey = "string",
                                                    TagValues = new[]
                                                    {
                                                        "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                                HasUniformYAxes = false,
                                LiveSpan = "string",
                                Title = "string",
                            },
                            SunburstDefinition = new Datadog.Inputs.DashboardWidgetSunburstDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                HideTotal = false,
                                LegendInline = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendInlineArgs
                                {
                                    Type = "string",
                                    HidePercent = false,
                                    HideValue = false,
                                },
                                LegendTable = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendTableArgs
                                {
                                    Type = "string",
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        AuditQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        NetworkQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Events = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                                    {
                                        Q = "string",
                                        TagsExecution = "string",
                                    },
                                },
                                LegendColumns = new[]
                                {
                                    "string",
                                },
                                LegendLayout = "string",
                                LegendSize = "string",
                                LiveSpan = "string",
                                Markers = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                                    {
                                        Value = "string",
                                        DisplayType = "string",
                                        Label = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        AuditQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        DisplayType = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Metadatas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs
                                            {
                                                Expression = "string",
                                                AliasName = "string",
                                            },
                                        },
                                        NetworkQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        OnRightYaxis = false,
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestStyleArgs
                                        {
                                            LineType = "string",
                                            LineWidth = "string",
                                            Palette = "string",
                                        },
                                    },
                                },
                                RightYaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRightYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                ShowLegend = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Yaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            ToplistDefinition = new Datadog.Inputs.DashboardWidgetToplistDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        AuditQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetToplistDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                Styles = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleArgs
                                    {
                                        Displays = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleDisplayArgs
                                            {
                                                Type = "string",
                                            },
                                        },
                                        Palette = "string",
                                        Scaling = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TopologyMapDefinition = new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionRequestArgs
                                    {
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionRequestQueryArgs
                                            {
                                                DataSource = "string",
                                                Filters = new[]
                                                {
                                                    "string",
                                                },
                                                Service = "string",
                                            },
                                        },
                                        RequestType = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TraceServiceDefinition = new Datadog.Inputs.DashboardWidgetTraceServiceDefinitionArgs
                            {
                                Service = "string",
                                Env = "string",
                                SpanName = "string",
                                ShowErrors = false,
                                ShowBreakdown = false,
                                ShowDistribution = false,
                                DisplayFormat = "string",
                                ShowHits = false,
                                ShowLatency = false,
                                ShowResourceList = false,
                                SizeFormat = "string",
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            TreemapDefinition = new Datadog.Inputs.DashboardWidgetTreemapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                NumberFormat = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                                {
                                                    Unit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                                    {
                                                        Canonical = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                        {
                                                            UnitName = "string",
                                                            PerUnitName = "string",
                                                        },
                                                        Custom = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                        {
                                                            Label = "string",
                                                        },
                                                    },
                                                    UnitScale = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                    {
                                                        UnitName = "string",
                                                    },
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                Title = "string",
                            },
                            WidgetLayout = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetWidgetLayoutArgs
                            {
                                Height = 0,
                                Width = 0,
                                X = 0,
                                Y = 0,
                                IsColumnBreak = false,
                            },
                        },
                    },
                },
                HeatmapDefinition = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Events = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Yaxis = new Datadog.Inputs.DashboardWidgetHeatmapDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                HostmapDefinition = new Datadog.Inputs.DashboardWidgetHostmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetHostmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Groups = new[]
                    {
                        "string",
                    },
                    NoGroupHosts = false,
                    NoMetricHosts = false,
                    NodeType = "string",
                    Request = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestArgs
                    {
                        Fills = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestFillArgs
                            {
                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestFillProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                        Sizes = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestSizeArgs
                            {
                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.DashboardWidgetHostmapDefinitionRequestSizeProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                    },
                    Scopes = new[]
                    {
                        "string",
                    },
                    Style = new Datadog.Inputs.DashboardWidgetHostmapDefinitionStyleArgs
                    {
                        FillMax = "string",
                        FillMin = "string",
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                Id = 0,
                IframeDefinition = new Datadog.Inputs.DashboardWidgetIframeDefinitionArgs
                {
                    Url = "string",
                },
                ImageDefinition = new Datadog.Inputs.DashboardWidgetImageDefinitionArgs
                {
                    Url = "string",
                    HasBackground = false,
                    HasBorder = false,
                    HorizontalAlign = "string",
                    Margin = "string",
                    Sizing = "string",
                    UrlDarkTheme = "string",
                    VerticalAlign = "string",
                },
                ListStreamDefinition = new Datadog.Inputs.DashboardWidgetListStreamDefinitionArgs
                {
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestArgs
                        {
                            Columns = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestColumnArgs
                                {
                                    Field = "string",
                                    Width = "string",
                                },
                            },
                            Query = new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQueryArgs
                            {
                                DataSource = "string",
                                ClusteringPatternFieldPath = "string",
                                EventSize = "string",
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQueryGroupByArgs
                                    {
                                        Facet = "string",
                                    },
                                },
                                Indexes = new[]
                                {
                                    "string",
                                },
                                QueryString = "string",
                                Sort = new Datadog.Inputs.DashboardWidgetListStreamDefinitionRequestQuerySortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Storage = "string",
                            },
                            ResponseFormat = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                LogStreamDefinition = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionArgs
                {
                    Columns = new[]
                    {
                        "string",
                    },
                    Indexes = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    MessageDisplay = "string",
                    Query = "string",
                    ShowDateColumn = false,
                    ShowMessageColumn = false,
                    Sort = new Datadog.Inputs.DashboardWidgetLogStreamDefinitionSortArgs
                    {
                        Column = "string",
                        Order = "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ManageStatusDefinition = new Datadog.Inputs.DashboardWidgetManageStatusDefinitionArgs
                {
                    Query = "string",
                    ColorPreference = "string",
                    DisplayFormat = "string",
                    HideZeroCounts = false,
                    ShowLastTriggered = false,
                    ShowPriority = false,
                    Sort = "string",
                    SummaryType = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                NoteDefinition = new Datadog.Inputs.DashboardWidgetNoteDefinitionArgs
                {
                    Content = "string",
                    BackgroundColor = "string",
                    FontSize = "string",
                    HasPadding = false,
                    ShowTick = false,
                    TextAlign = "string",
                    TickEdge = "string",
                    TickPos = "string",
                    VerticalAlign = "string",
                },
                PowerpackDefinition = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionArgs
                {
                    PowerpackId = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    ShowTitle = false,
                    TemplateVariables = new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs
                    {
                        ControlledByPowerpacks = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs
                            {
                                Name = "string",
                                Values = new[]
                                {
                                    "string",
                                },
                                Prefix = "string",
                            },
                        },
                        ControlledExternallies = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs
                            {
                                Name = "string",
                                Values = new[]
                                {
                                    "string",
                                },
                                Prefix = "string",
                            },
                        },
                    },
                    Title = "string",
                },
                QueryTableDefinition = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    HasSearchBar = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            Alias = "string",
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            CellDisplayModes = new[]
                            {
                                "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    CellDisplayModeOptions = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                    {
                                        TrendType = "string",
                                        YScale = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Limit = 0,
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Order = "string",
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            TextFormats = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs
                                {
                                    TextFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                        {
                                            Match = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                            {
                                                Type = "string",
                                                Value = "string",
                                            },
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            Palette = "string",
                                            Replace = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                            {
                                                Type = "string",
                                                With = "string",
                                                Substring = "string",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                QueryValueDefinition = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionArgs
                {
                    Autoscale = false,
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    CustomUnit = "string",
                    LiveSpan = "string",
                    Precision = 0,
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    TextAlign = "string",
                    TimeseriesBackground = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                    {
                        Type = "string",
                        Yaxis = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                        {
                            IncludeZero = false,
                            Label = "string",
                            Max = "string",
                            Min = "string",
                            Scale = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                RunWorkflowDefinition = new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionArgs
                {
                    WorkflowId = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Inputs = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetRunWorkflowDefinitionInputArgs
                        {
                            Name = "string",
                            Value = "string",
                        },
                    },
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionArgs
                {
                    ColorByGroups = new[]
                    {
                        "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Request = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestArgs
                    {
                        ScatterplotTables = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                    {
                                        Dimension = "string",
                                        FormulaExpression = "string",
                                        Alias = "string",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                    {
                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                        {
                                            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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                        {
                                            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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                        {
                                            DataSource = "string",
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                        },
                                        EventQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                        {
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Interval = 0,
                                                    Metric = "string",
                                                },
                                            },
                                            DataSource = "string",
                                            Name = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            Search = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                            {
                                                Query = "string",
                                            },
                                            Storage = "string",
                                        },
                                        MetricQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                        {
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            DataSource = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                        {
                                            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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                        {
                                            DataSource = "string",
                                            Measure = "string",
                                            SloId = "string",
                                            AdditionalQueryFilters = "string",
                                            CrossOrgUuids = "string",
                                            GroupMode = "string",
                                            Name = "string",
                                            SloQueryType = "string",
                                        },
                                    },
                                },
                            },
                        },
                        Xes = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXArgs
                            {
                                Aggregator = "string",
                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                        Ys = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYArgs
                            {
                                Aggregator = "string",
                                ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionXaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    Yaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardWidgetServiceLevelObjectiveDefinitionArgs
                {
                    SloId = "string",
                    TimeWindows = new[]
                    {
                        "string",
                    },
                    ViewMode = "string",
                    ViewType = "string",
                    AdditionalQueryFilters = "string",
                    GlobalTimeTarget = "string",
                    ShowErrorBudget = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ServicemapDefinition = new Datadog.Inputs.DashboardWidgetServicemapDefinitionArgs
                {
                    Filters = new[]
                    {
                        "string",
                    },
                    Service = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetServicemapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SloListDefinition = new Datadog.Inputs.DashboardWidgetSloListDefinitionArgs
                {
                    Request = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestArgs
                    {
                        Query = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestQueryArgs
                        {
                            QueryString = "string",
                            Limit = 0,
                            Sort = new Datadog.Inputs.DashboardWidgetSloListDefinitionRequestQuerySortArgs
                            {
                                Column = "string",
                                Order = "string",
                            },
                        },
                        RequestType = "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SplitGraphDefinition = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionArgs
                {
                    Size = "string",
                    SourceWidgetDefinition = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSourceWidgetDefinitionArgs
                    {
                        ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                                {
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ChangeType = "string",
                                    CompareTo = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    IncreaseGood = false,
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    OrderBy = "string",
                                    OrderDir = "string",
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ShowPresent = false,
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                        {
                            View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                            {
                                Focus = "string",
                            },
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                                {
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                DataSource = "string",
                                                Env = "string",
                                                Name = "string",
                                                OperationName = "string",
                                                ResourceName = "string",
                                                Service = "string",
                                                Stat = "string",
                                                CrossOrgUuids = "string",
                                                IsUpstream = false,
                                                PrimaryTagName = "string",
                                                PrimaryTagValue = "string",
                                            },
                                            ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                },
                            },
                            Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                            {
                                Palette = "string",
                                PaletteFlip = false,
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        QueryTableDefinition = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            HasSearchBar = "string",
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestArgs
                                {
                                    Aggregator = "string",
                                    Alias = "string",
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ApmStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                                    {
                                        Env = "string",
                                        Name = "string",
                                        PrimaryTag = "string",
                                        RowType = "string",
                                        Service = "string",
                                        Columns = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                            {
                                                Name = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                Order = "string",
                                            },
                                        },
                                        Resource = "string",
                                    },
                                    CellDisplayModes = new[]
                                    {
                                        "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            CellDisplayModeOptions = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs
                                            {
                                                TrendType = "string",
                                                YScale = "string",
                                            },
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Limit = 0,
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Order = "string",
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    TextFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs
                                        {
                                            TextFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                                {
                                                    Match = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                                    {
                                                        Type = "string",
                                                        Value = "string",
                                                    },
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    Palette = "string",
                                                    Replace = new Datadog.Inputs.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                                    {
                                                        Type = "string",
                                                        With = "string",
                                                        Substring = "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        QueryValueDefinition = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionArgs
                        {
                            Autoscale = false,
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            CustomUnit = "string",
                            LiveSpan = "string",
                            Precision = 0,
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestArgs
                                {
                                    Aggregator = "string",
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    AuditQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                },
                            },
                            TextAlign = "string",
                            TimeseriesBackground = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                            {
                                Type = "string",
                                Yaxis = new Datadog.Inputs.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionArgs
                        {
                            ColorByGroups = new[]
                            {
                                "string",
                            },
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetScatterplotDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            LiveSpan = "string",
                            Request = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestArgs
                            {
                                ScatterplotTables = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                            {
                                                Dimension = "string",
                                                FormulaExpression = "string",
                                                Alias = "string",
                                            },
                                        },
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                {
                                                    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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                {
                                                    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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    CrossOrgUuids = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                {
                                                    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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    CrossOrgUuids = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                    },
                                },
                                Xes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXArgs
                                    {
                                        Aggregator = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                Ys = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYArgs
                                    {
                                        Aggregator = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                            Xaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionXaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                            Yaxis = new Datadog.Inputs.DashboardWidgetScatterplotDefinitionYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                        },
                        SunburstDefinition = new Datadog.Inputs.DashboardWidgetSunburstDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            HideTotal = false,
                            LegendInline = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendInlineArgs
                            {
                                Type = "string",
                                HidePercent = false,
                                HideValue = false,
                            },
                            LegendTable = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendTableArgs
                            {
                                Type = "string",
                            },
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestArgs
                                {
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    AuditQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    NetworkQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestStyleArgs
                                    {
                                        Palette = "string",
                                    },
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Events = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                                {
                                    Q = "string",
                                    TagsExecution = "string",
                                },
                            },
                            LegendColumns = new[]
                            {
                                "string",
                            },
                            LegendLayout = "string",
                            LegendSize = "string",
                            LiveSpan = "string",
                            Markers = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                                {
                                    Value = "string",
                                    DisplayType = "string",
                                    Label = "string",
                                },
                            },
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                                {
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    AuditQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    DisplayType = "string",
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Metadatas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs
                                        {
                                            Expression = "string",
                                            AliasName = "string",
                                        },
                                    },
                                    NetworkQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    OnRightYaxis = false,
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestStyleArgs
                                    {
                                        LineType = "string",
                                        LineWidth = "string",
                                        Palette = "string",
                                    },
                                },
                            },
                            RightYaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRightYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                            ShowLegend = false,
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                            Yaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs
                            {
                                IncludeZero = false,
                                Label = "string",
                                Max = "string",
                                Min = "string",
                                Scale = "string",
                            },
                        },
                        ToplistDefinition = new Datadog.Inputs.DashboardWidgetToplistDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            LiveSpan = "string",
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestArgs
                                {
                                    ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    AuditQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestProcessQueryArgs
                                    {
                                        Metric = "string",
                                        FilterBies = new[]
                                        {
                                            "string",
                                        },
                                        Limit = 0,
                                        SearchBy = "string",
                                    },
                                    Q = "string",
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetToplistDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                    RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                                    {
                                        Index = "string",
                                        ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Order = "string",
                                                    Facet = "string",
                                                },
                                            },
                                        },
                                        MultiComputes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                        },
                                        SearchQuery = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestStyleArgs
                                    {
                                        Palette = "string",
                                    },
                                },
                            },
                            Styles = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleArgs
                                {
                                    Displays = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleDisplayArgs
                                        {
                                            Type = "string",
                                        },
                                    },
                                    Palette = "string",
                                    Scaling = "string",
                                },
                            },
                            Title = "string",
                            TitleAlign = "string",
                            TitleSize = "string",
                        },
                        TreemapDefinition = new Datadog.Inputs.DashboardWidgetTreemapDefinitionArgs
                        {
                            CustomLinks = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionCustomLinkArgs
                                {
                                    IsHidden = false,
                                    Label = "string",
                                    Link = "string",
                                    OverrideLabel = "string",
                                },
                            },
                            Requests = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestArgs
                                {
                                    Formulas = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaArgs
                                        {
                                            FormulaExpression = "string",
                                            Alias = "string",
                                            CellDisplayMode = "string",
                                            ConditionalFormats = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                                {
                                                    Comparator = "string",
                                                    Palette = "string",
                                                    Value = 0,
                                                    CustomBgColor = "string",
                                                    CustomFgColor = "string",
                                                    HideValue = false,
                                                    ImageUrl = "string",
                                                    Metric = "string",
                                                    Timeframe = "string",
                                                },
                                            },
                                            Limit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaLimitArgs
                                            {
                                                Count = 0,
                                                Order = "string",
                                            },
                                            NumberFormat = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                            {
                                                Unit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                                {
                                                    Canonical = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                                    {
                                                        UnitName = "string",
                                                        PerUnitName = "string",
                                                    },
                                                    Custom = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                                    {
                                                        Label = "string",
                                                    },
                                                },
                                                UnitScale = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                                {
                                                    UnitName = "string",
                                                },
                                            },
                                            Style = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaStyleArgs
                                            {
                                                Palette = "string",
                                                PaletteIndex = 0,
                                            },
                                        },
                                    },
                                    Queries = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryArgs
                                        {
                                            ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                            {
                                                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.DashboardWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                            {
                                                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.DashboardWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                            {
                                                DataSource = "string",
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                            },
                                            EventQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                            {
                                                Computes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Interval = 0,
                                                        Metric = "string",
                                                    },
                                                },
                                                DataSource = "string",
                                                Name = "string",
                                                CrossOrgUuids = "string",
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        Sort = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                        {
                                                            Aggregation = "string",
                                                            Metric = "string",
                                                            Order = "string",
                                                        },
                                                    },
                                                },
                                                Indexes = new[]
                                                {
                                                    "string",
                                                },
                                                Search = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                                {
                                                    Query = "string",
                                                },
                                                Storage = "string",
                                            },
                                            MetricQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                            {
                                                Name = "string",
                                                Query = "string",
                                                Aggregator = "string",
                                                CrossOrgUuids = "string",
                                                DataSource = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                            {
                                                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.DashboardWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                            {
                                                DataSource = "string",
                                                Measure = "string",
                                                SloId = "string",
                                                AdditionalQueryFilters = "string",
                                                CrossOrgUuids = "string",
                                                GroupMode = "string",
                                                Name = "string",
                                                SloQueryType = "string",
                                            },
                                        },
                                    },
                                },
                            },
                            Title = "string",
                        },
                    },
                    SplitConfig = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigArgs
                    {
                        Sort = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSortArgs
                        {
                            Order = "string",
                            Compute = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSortComputeArgs
                            {
                                Metric = "string",
                                Aggregation = "string",
                            },
                        },
                        SplitDimensions = new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigSplitDimensionsArgs
                        {
                            OneGraphPer = "string",
                        },
                        Limit = 0,
                        StaticSplits = new[]
                        {
                            new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitArgs
                            {
                                SplitVectors = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArgs
                                    {
                                        TagKey = "string",
                                        TagValues = new[]
                                        {
                                            "string",
                                        },
                                    },
                                },
                            },
                        },
                    },
                    HasUniformYAxes = false,
                    LiveSpan = "string",
                    Title = "string",
                },
                SunburstDefinition = new Datadog.Inputs.DashboardWidgetSunburstDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    HideTotal = false,
                    LegendInline = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendInlineArgs
                    {
                        Type = "string",
                        HidePercent = false,
                        HideValue = false,
                    },
                    LegendTable = new Datadog.Inputs.DashboardWidgetSunburstDefinitionLegendTableArgs
                    {
                        Type = "string",
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            NetworkQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetSunburstDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TimeseriesDefinition = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Events = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    LegendColumns = new[]
                    {
                        "string",
                    },
                    LegendLayout = "string",
                    LegendSize = "string",
                    LiveSpan = "string",
                    Markers = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionMarkerArgs
                        {
                            Value = "string",
                            DisplayType = "string",
                            Label = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            DisplayType = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Metadatas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs
                                {
                                    Expression = "string",
                                    AliasName = "string",
                                },
                            },
                            NetworkQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OnRightYaxis = false,
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRequestStyleArgs
                            {
                                LineType = "string",
                                LineWidth = "string",
                                Palette = "string",
                            },
                        },
                    },
                    RightYaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionRightYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Yaxis = new Datadog.Inputs.DashboardWidgetTimeseriesDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ToplistDefinition = new Datadog.Inputs.DashboardWidgetToplistDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetToplistDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetToplistDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetToplistDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    Styles = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleArgs
                        {
                            Displays = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetToplistDefinitionStyleDisplayArgs
                                {
                                    Type = "string",
                                },
                            },
                            Palette = "string",
                            Scaling = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TopologyMapDefinition = new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionRequestArgs
                        {
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTopologyMapDefinitionRequestQueryArgs
                                {
                                    DataSource = "string",
                                    Filters = new[]
                                    {
                                        "string",
                                    },
                                    Service = "string",
                                },
                            },
                            RequestType = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TraceServiceDefinition = new Datadog.Inputs.DashboardWidgetTraceServiceDefinitionArgs
                {
                    Service = "string",
                    Env = "string",
                    SpanName = "string",
                    ShowErrors = false,
                    ShowBreakdown = false,
                    ShowDistribution = false,
                    DisplayFormat = "string",
                    ShowHits = false,
                    ShowLatency = false,
                    ShowResourceList = false,
                    SizeFormat = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TreemapDefinition = new Datadog.Inputs.DashboardWidgetTreemapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    NumberFormat = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatArgs
                                    {
                                        Unit = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs
                                        {
                                            Canonical = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs
                                            {
                                                UnitName = "string",
                                                PerUnitName = "string",
                                            },
                                            Custom = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs
                                            {
                                                Label = "string",
                                            },
                                        },
                                        UnitScale = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs
                                        {
                                            UnitName = "string",
                                        },
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        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.DashboardWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        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.DashboardWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        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.DashboardWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    Title = "string",
                },
                WidgetLayout = new Datadog.Inputs.DashboardWidgetWidgetLayoutArgs
                {
                    Height = 0,
                    Width = 0,
                    X = 0,
                    Y = 0,
                    IsColumnBreak = false,
                },
            },
        },
    });
    
    example, err := datadog.NewDashboard(ctx, "dashboardResource", &datadog.DashboardArgs{
    	LayoutType: pulumi.String("string"),
    	Title:      pulumi.String("string"),
    	RestrictedRoles: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	NotifyLists: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	ReflowType: pulumi.String("string"),
    	DashboardLists: pulumi.IntArray{
    		pulumi.Int(0),
    	},
    	Tags: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	TemplateVariablePresets: datadog.DashboardTemplateVariablePresetArray{
    		&datadog.DashboardTemplateVariablePresetArgs{
    			Name: pulumi.String("string"),
    			TemplateVariables: datadog.DashboardTemplateVariablePresetTemplateVariableArray{
    				&datadog.DashboardTemplateVariablePresetTemplateVariableArgs{
    					Name: pulumi.String("string"),
    					Values: pulumi.StringArray{
    						pulumi.String("string"),
    					},
    				},
    			},
    		},
    	},
    	TemplateVariables: datadog.DashboardTemplateVariableArray{
    		&datadog.DashboardTemplateVariableArgs{
    			Name: pulumi.String("string"),
    			AvailableValues: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Defaults: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    			Prefix: pulumi.String("string"),
    		},
    	},
    	Description: pulumi.String("string"),
    	Url:         pulumi.String("string"),
    	Widgets: datadog.DashboardWidgetArray{
    		&datadog.DashboardWidgetArgs{
    			AlertGraphDefinition: &datadog.DashboardWidgetAlertGraphDefinitionArgs{
    				AlertId:    pulumi.String("string"),
    				VizType:    pulumi.String("string"),
    				LiveSpan:   pulumi.String("string"),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			AlertValueDefinition: &datadog.DashboardWidgetAlertValueDefinitionArgs{
    				AlertId:    pulumi.String("string"),
    				Precision:  pulumi.Int(0),
    				TextAlign:  pulumi.String("string"),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Unit:       pulumi.String("string"),
    			},
    			ChangeDefinition: &datadog.DashboardWidgetChangeDefinitionArgs{
    				CustomLinks: datadog.DashboardWidgetChangeDefinitionCustomLinkArray{
    					&datadog.DashboardWidgetChangeDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				LiveSpan: pulumi.String("string"),
    				Requests: datadog.DashboardWidgetChangeDefinitionRequestArray{
    					&datadog.DashboardWidgetChangeDefinitionRequestArgs{
    						ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    								&datadog.DashboardWidgetApmQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    								&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ChangeType: pulumi.String("string"),
    						CompareTo:  pulumi.String("string"),
    						Formulas: datadog.DashboardWidgetChangeDefinitionRequestFormulaArray{
    							&datadog.DashboardWidgetChangeDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								ConditionalFormats: datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    										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.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											UnitName:    pulumi.String("string"),
    											PerUnitName: pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						IncreaseGood: pulumi.Bool(false),
    						LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    								&datadog.DashboardWidgetLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    								&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						OrderBy:  pulumi.String("string"),
    						OrderDir: pulumi.String("string"),
    						ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestProcessQueryArgs{
    							Metric: pulumi.String("string"),
    							FilterBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Limit:    pulumi.Int(0),
    							SearchBy: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						Queries: datadog.DashboardWidgetChangeDefinitionRequestQueryArray{
    							&datadog.DashboardWidgetChangeDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									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.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    									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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    											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.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs{
    									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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs{
    									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"),
    								},
    							},
    						},
    						RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    								&datadog.DashboardWidgetRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    								&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    								&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    								&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ShowPresent: pulumi.Bool(false),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			CheckStatusDefinition: &datadog.DashboardWidgetCheckStatusDefinitionArgs{
    				Check:    pulumi.String("string"),
    				Grouping: pulumi.String("string"),
    				Group:    pulumi.String("string"),
    				GroupBies: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				LiveSpan: pulumi.String("string"),
    				Tags: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			DistributionDefinition: &datadog.DashboardWidgetDistributionDefinitionArgs{
    				LegendSize: pulumi.String("string"),
    				LiveSpan:   pulumi.String("string"),
    				Requests: datadog.DashboardWidgetDistributionDefinitionRequestArray{
    					&datadog.DashboardWidgetDistributionDefinitionRequestArgs{
    						ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    								&datadog.DashboardWidgetApmQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    								&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ApmStatsQuery: &datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs{
    							Env:        pulumi.String("string"),
    							Name:       pulumi.String("string"),
    							PrimaryTag: pulumi.String("string"),
    							RowType:    pulumi.String("string"),
    							Service:    pulumi.String("string"),
    							Columns: datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArray{
    								&datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs{
    									Name:            pulumi.String("string"),
    									Alias:           pulumi.String("string"),
    									CellDisplayMode: pulumi.String("string"),
    									Order:           pulumi.String("string"),
    								},
    							},
    							Resource: pulumi.String("string"),
    						},
    						LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    								&datadog.DashboardWidgetLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    								&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ProcessQuery: &datadog.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs{
    							Metric: pulumi.String("string"),
    							FilterBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Limit:    pulumi.Int(0),
    							SearchBy: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    								&datadog.DashboardWidgetRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    								&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    								&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    								&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Style: &datadog.DashboardWidgetDistributionDefinitionRequestStyleArgs{
    							Palette: pulumi.String("string"),
    						},
    					},
    				},
    				ShowLegend: pulumi.Bool(false),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Xaxis: &datadog.DashboardWidgetDistributionDefinitionXaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    				Yaxis: &datadog.DashboardWidgetDistributionDefinitionYaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    			},
    			EventStreamDefinition: &datadog.DashboardWidgetEventStreamDefinitionArgs{
    				Query:         pulumi.String("string"),
    				EventSize:     pulumi.String("string"),
    				LiveSpan:      pulumi.String("string"),
    				TagsExecution: pulumi.String("string"),
    				Title:         pulumi.String("string"),
    				TitleAlign:    pulumi.String("string"),
    				TitleSize:     pulumi.String("string"),
    			},
    			EventTimelineDefinition: &datadog.DashboardWidgetEventTimelineDefinitionArgs{
    				Query:         pulumi.String("string"),
    				LiveSpan:      pulumi.String("string"),
    				TagsExecution: pulumi.String("string"),
    				Title:         pulumi.String("string"),
    				TitleAlign:    pulumi.String("string"),
    				TitleSize:     pulumi.String("string"),
    			},
    			FreeTextDefinition: &datadog.DashboardWidgetFreeTextDefinitionArgs{
    				Text:      pulumi.String("string"),
    				Color:     pulumi.String("string"),
    				FontSize:  pulumi.String("string"),
    				TextAlign: pulumi.String("string"),
    			},
    			GeomapDefinition: &datadog.DashboardWidgetGeomapDefinitionArgs{
    				View: &datadog.DashboardWidgetGeomapDefinitionViewArgs{
    					Focus: pulumi.String("string"),
    				},
    				CustomLinks: datadog.DashboardWidgetGeomapDefinitionCustomLinkArray{
    					&datadog.DashboardWidgetGeomapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				LiveSpan: pulumi.String("string"),
    				Requests: datadog.DashboardWidgetGeomapDefinitionRequestArray{
    					&datadog.DashboardWidgetGeomapDefinitionRequestArgs{
    						Formulas: datadog.DashboardWidgetGeomapDefinitionRequestFormulaArray{
    							&datadog.DashboardWidgetGeomapDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								ConditionalFormats: datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    										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.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								NumberFormat: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs{
    									Unit: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    										Canonical: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    											UnitName:    pulumi.String("string"),
    											PerUnitName: pulumi.String("string"),
    										},
    										Custom: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    											Label: pulumi.String("string"),
    										},
    									},
    									UnitScale: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    										UnitName: pulumi.String("string"),
    									},
    								},
    								Style: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    								&datadog.DashboardWidgetLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    								&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						Queries: datadog.DashboardWidgetGeomapDefinitionRequestQueryArray{
    							&datadog.DashboardWidgetGeomapDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									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.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    									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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    											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.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    									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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs{
    									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"),
    								},
    							},
    						},
    						RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    								&datadog.DashboardWidgetRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    								&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    					},
    				},
    				Style: &datadog.DashboardWidgetGeomapDefinitionStyleArgs{
    					Palette:     pulumi.String("string"),
    					PaletteFlip: pulumi.Bool(false),
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			GroupDefinition: &datadog.DashboardWidgetGroupDefinitionArgs{
    				LayoutType:      pulumi.String("string"),
    				BackgroundColor: pulumi.String("string"),
    				BannerImg:       pulumi.String("string"),
    				ShowTitle:       pulumi.Bool(false),
    				Title:           pulumi.String("string"),
    				Widgets: datadog.DashboardWidgetGroupDefinitionWidgetArray{
    					&datadog.DashboardWidgetGroupDefinitionWidgetArgs{
    						AlertGraphDefinition: &datadog.DashboardWidgetAlertGraphDefinitionArgs{
    							AlertId:    pulumi.String("string"),
    							VizType:    pulumi.String("string"),
    							LiveSpan:   pulumi.String("string"),
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						AlertValueDefinition: &datadog.DashboardWidgetAlertValueDefinitionArgs{
    							AlertId:    pulumi.String("string"),
    							Precision:  pulumi.Int(0),
    							TextAlign:  pulumi.String("string"),
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Unit:       pulumi.String("string"),
    						},
    						ChangeDefinition: &datadog.DashboardWidgetChangeDefinitionArgs{
    							CustomLinks: datadog.DashboardWidgetChangeDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetChangeDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							LiveSpan: pulumi.String("string"),
    							Requests: datadog.DashboardWidgetChangeDefinitionRequestArray{
    								&datadog.DashboardWidgetChangeDefinitionRequestArgs{
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ChangeType: pulumi.String("string"),
    									CompareTo:  pulumi.String("string"),
    									Formulas: datadog.DashboardWidgetChangeDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetChangeDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											ConditionalFormats: datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									IncreaseGood: pulumi.Bool(false),
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									OrderBy:  pulumi.String("string"),
    									OrderDir: pulumi.String("string"),
    									ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetChangeDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetChangeDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ShowPresent: pulumi.Bool(false),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						CheckStatusDefinition: &datadog.DashboardWidgetCheckStatusDefinitionArgs{
    							Check:    pulumi.String("string"),
    							Grouping: pulumi.String("string"),
    							Group:    pulumi.String("string"),
    							GroupBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							LiveSpan: pulumi.String("string"),
    							Tags: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						DistributionDefinition: &datadog.DashboardWidgetDistributionDefinitionArgs{
    							LegendSize: pulumi.String("string"),
    							LiveSpan:   pulumi.String("string"),
    							Requests: datadog.DashboardWidgetDistributionDefinitionRequestArray{
    								&datadog.DashboardWidgetDistributionDefinitionRequestArgs{
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ApmStatsQuery: &datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs{
    										Env:        pulumi.String("string"),
    										Name:       pulumi.String("string"),
    										PrimaryTag: pulumi.String("string"),
    										RowType:    pulumi.String("string"),
    										Service:    pulumi.String("string"),
    										Columns: datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArray{
    											&datadog.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs{
    												Name:            pulumi.String("string"),
    												Alias:           pulumi.String("string"),
    												CellDisplayMode: pulumi.String("string"),
    												Order:           pulumi.String("string"),
    											},
    										},
    										Resource: pulumi.String("string"),
    									},
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ProcessQuery: &datadog.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Style: &datadog.DashboardWidgetDistributionDefinitionRequestStyleArgs{
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							ShowLegend: pulumi.Bool(false),
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Xaxis: &datadog.DashboardWidgetDistributionDefinitionXaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    							Yaxis: &datadog.DashboardWidgetDistributionDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						EventStreamDefinition: &datadog.DashboardWidgetEventStreamDefinitionArgs{
    							Query:         pulumi.String("string"),
    							EventSize:     pulumi.String("string"),
    							LiveSpan:      pulumi.String("string"),
    							TagsExecution: pulumi.String("string"),
    							Title:         pulumi.String("string"),
    							TitleAlign:    pulumi.String("string"),
    							TitleSize:     pulumi.String("string"),
    						},
    						EventTimelineDefinition: &datadog.DashboardWidgetEventTimelineDefinitionArgs{
    							Query:         pulumi.String("string"),
    							LiveSpan:      pulumi.String("string"),
    							TagsExecution: pulumi.String("string"),
    							Title:         pulumi.String("string"),
    							TitleAlign:    pulumi.String("string"),
    							TitleSize:     pulumi.String("string"),
    						},
    						FreeTextDefinition: &datadog.DashboardWidgetFreeTextDefinitionArgs{
    							Text:      pulumi.String("string"),
    							Color:     pulumi.String("string"),
    							FontSize:  pulumi.String("string"),
    							TextAlign: pulumi.String("string"),
    						},
    						GeomapDefinition: &datadog.DashboardWidgetGeomapDefinitionArgs{
    							View: &datadog.DashboardWidgetGeomapDefinitionViewArgs{
    								Focus: pulumi.String("string"),
    							},
    							CustomLinks: datadog.DashboardWidgetGeomapDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetGeomapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							LiveSpan: pulumi.String("string"),
    							Requests: datadog.DashboardWidgetGeomapDefinitionRequestArray{
    								&datadog.DashboardWidgetGeomapDefinitionRequestArgs{
    									Formulas: datadog.DashboardWidgetGeomapDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetGeomapDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											ConditionalFormats: datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetGeomapDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetGeomapDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    								},
    							},
    							Style: &datadog.DashboardWidgetGeomapDefinitionStyleArgs{
    								Palette:     pulumi.String("string"),
    								PaletteFlip: pulumi.Bool(false),
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						HeatmapDefinition: &datadog.DashboardWidgetHeatmapDefinitionArgs{
    							CustomLinks: datadog.DashboardWidgetHeatmapDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetHeatmapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Events: datadog.DashboardWidgetHeatmapDefinitionEventArray{
    								&datadog.DashboardWidgetHeatmapDefinitionEventArgs{
    									Q:             pulumi.String("string"),
    									TagsExecution: pulumi.String("string"),
    								},
    							},
    							LegendSize: pulumi.String("string"),
    							LiveSpan:   pulumi.String("string"),
    							Requests: datadog.DashboardWidgetHeatmapDefinitionRequestArray{
    								&datadog.DashboardWidgetHeatmapDefinitionRequestArgs{
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Formulas: datadog.DashboardWidgetHeatmapDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetHeatmapDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											ConditionalFormats: datadog.DashboardWidgetHeatmapDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetHeatmapDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetHeatmapDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ProcessQuery: &datadog.DashboardWidgetHeatmapDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetHeatmapDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetHeatmapDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetHeatmapDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetHeatmapDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Style: &datadog.DashboardWidgetHeatmapDefinitionRequestStyleArgs{
    										Palette: pulumi.String("string"),
    									},
    								},
    							},
    							ShowLegend: pulumi.Bool(false),
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Yaxis: &datadog.DashboardWidgetHeatmapDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						HostmapDefinition: &datadog.DashboardWidgetHostmapDefinitionArgs{
    							CustomLinks: datadog.DashboardWidgetHostmapDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetHostmapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Groups: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							NoGroupHosts:  pulumi.Bool(false),
    							NoMetricHosts: pulumi.Bool(false),
    							NodeType:      pulumi.String("string"),
    							Request: &datadog.DashboardWidgetHostmapDefinitionRequestArgs{
    								Fills: datadog.DashboardWidgetHostmapDefinitionRequestFillArray{
    									&datadog.DashboardWidgetHostmapDefinitionRequestFillArgs{
    										ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    												&datadog.DashboardWidgetApmQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    												&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    												&datadog.DashboardWidgetLogQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    												&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardWidgetHostmapDefinitionRequestFillProcessQueryArgs{
    											Metric: pulumi.String("string"),
    											FilterBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit:    pulumi.Int(0),
    											SearchBy: pulumi.String("string"),
    										},
    										Q: pulumi.String("string"),
    										RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    												&datadog.DashboardWidgetRumQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    												&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    												&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    												&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    									},
    								},
    								Sizes: datadog.DashboardWidgetHostmapDefinitionRequestSizeArray{
    									&datadog.DashboardWidgetHostmapDefinitionRequestSizeArgs{
    										ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    												&datadog.DashboardWidgetApmQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    												&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    												&datadog.DashboardWidgetLogQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    												&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardWidgetHostmapDefinitionRequestSizeProcessQueryArgs{
    											Metric: pulumi.String("string"),
    											FilterBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit:    pulumi.Int(0),
    											SearchBy: pulumi.String("string"),
    										},
    										Q: pulumi.String("string"),
    										RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    												&datadog.DashboardWidgetRumQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    												&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    												&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    												&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    									},
    								},
    							},
    							Scopes: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Style: &datadog.DashboardWidgetHostmapDefinitionStyleArgs{
    								FillMax:     pulumi.String("string"),
    								FillMin:     pulumi.String("string"),
    								Palette:     pulumi.String("string"),
    								PaletteFlip: pulumi.Bool(false),
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						Id: pulumi.Int(0),
    						IframeDefinition: &datadog.DashboardWidgetIframeDefinitionArgs{
    							Url: pulumi.String("string"),
    						},
    						ImageDefinition: &datadog.DashboardWidgetImageDefinitionArgs{
    							Url:             pulumi.String("string"),
    							HasBackground:   pulumi.Bool(false),
    							HasBorder:       pulumi.Bool(false),
    							HorizontalAlign: pulumi.String("string"),
    							Margin:          pulumi.String("string"),
    							Sizing:          pulumi.String("string"),
    							UrlDarkTheme:    pulumi.String("string"),
    							VerticalAlign:   pulumi.String("string"),
    						},
    						ListStreamDefinition: &datadog.DashboardWidgetListStreamDefinitionArgs{
    							Requests: datadog.DashboardWidgetListStreamDefinitionRequestArray{
    								&datadog.DashboardWidgetListStreamDefinitionRequestArgs{
    									Columns: datadog.DashboardWidgetListStreamDefinitionRequestColumnArray{
    										&datadog.DashboardWidgetListStreamDefinitionRequestColumnArgs{
    											Field: pulumi.String("string"),
    											Width: pulumi.String("string"),
    										},
    									},
    									Query: &datadog.DashboardWidgetListStreamDefinitionRequestQueryArgs{
    										DataSource:                 pulumi.String("string"),
    										ClusteringPatternFieldPath: pulumi.String("string"),
    										EventSize:                  pulumi.String("string"),
    										GroupBies: datadog.DashboardWidgetListStreamDefinitionRequestQueryGroupByArray{
    											&datadog.DashboardWidgetListStreamDefinitionRequestQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    											},
    										},
    										Indexes: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										QueryString: pulumi.String("string"),
    										Sort: &datadog.DashboardWidgetListStreamDefinitionRequestQuerySortArgs{
    											Column: pulumi.String("string"),
    											Order:  pulumi.String("string"),
    										},
    										Storage: pulumi.String("string"),
    									},
    									ResponseFormat: pulumi.String("string"),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						LogStreamDefinition: &datadog.DashboardWidgetLogStreamDefinitionArgs{
    							Columns: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							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.DashboardWidgetLogStreamDefinitionSortArgs{
    								Column: pulumi.String("string"),
    								Order:  pulumi.String("string"),
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ManageStatusDefinition: &datadog.DashboardWidgetManageStatusDefinitionArgs{
    							Query:             pulumi.String("string"),
    							ColorPreference:   pulumi.String("string"),
    							DisplayFormat:     pulumi.String("string"),
    							HideZeroCounts:    pulumi.Bool(false),
    							ShowLastTriggered: pulumi.Bool(false),
    							ShowPriority:      pulumi.Bool(false),
    							Sort:              pulumi.String("string"),
    							SummaryType:       pulumi.String("string"),
    							Title:             pulumi.String("string"),
    							TitleAlign:        pulumi.String("string"),
    							TitleSize:         pulumi.String("string"),
    						},
    						NoteDefinition: &datadog.DashboardWidgetNoteDefinitionArgs{
    							Content:         pulumi.String("string"),
    							BackgroundColor: pulumi.String("string"),
    							FontSize:        pulumi.String("string"),
    							HasPadding:      pulumi.Bool(false),
    							ShowTick:        pulumi.Bool(false),
    							TextAlign:       pulumi.String("string"),
    							TickEdge:        pulumi.String("string"),
    							TickPos:         pulumi.String("string"),
    							VerticalAlign:   pulumi.String("string"),
    						},
    						PowerpackDefinition: &datadog.DashboardWidgetPowerpackDefinitionArgs{
    							PowerpackId:     pulumi.String("string"),
    							BackgroundColor: pulumi.String("string"),
    							BannerImg:       pulumi.String("string"),
    							ShowTitle:       pulumi.Bool(false),
    							TemplateVariables: &datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesArgs{
    								ControlledByPowerpacks: datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArray{
    									&datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs{
    										Name: pulumi.String("string"),
    										Values: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Prefix: pulumi.String("string"),
    									},
    								},
    								ControlledExternallies: datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArray{
    									&datadog.DashboardWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs{
    										Name: pulumi.String("string"),
    										Values: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Prefix: pulumi.String("string"),
    									},
    								},
    							},
    							Title: pulumi.String("string"),
    						},
    						QueryTableDefinition: &datadog.DashboardWidgetQueryTableDefinitionArgs{
    							CustomLinks: datadog.DashboardWidgetQueryTableDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetQueryTableDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							HasSearchBar: pulumi.String("string"),
    							LiveSpan:     pulumi.String("string"),
    							Requests: datadog.DashboardWidgetQueryTableDefinitionRequestArray{
    								&datadog.DashboardWidgetQueryTableDefinitionRequestArgs{
    									Aggregator: pulumi.String("string"),
    									Alias:      pulumi.String("string"),
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ApmStatsQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs{
    										Env:        pulumi.String("string"),
    										Name:       pulumi.String("string"),
    										PrimaryTag: pulumi.String("string"),
    										RowType:    pulumi.String("string"),
    										Service:    pulumi.String("string"),
    										Columns: datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArray{
    											&datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs{
    												Name:            pulumi.String("string"),
    												Alias:           pulumi.String("string"),
    												CellDisplayMode: pulumi.String("string"),
    												Order:           pulumi.String("string"),
    											},
    										},
    										Resource: pulumi.String("string"),
    									},
    									CellDisplayModes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									ConditionalFormats: datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArray{
    										&datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs{
    											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.DashboardWidgetQueryTableDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetQueryTableDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											CellDisplayModeOptions: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    												TrendType: pulumi.String("string"),
    												YScale:    pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									Limit: pulumi.Int(0),
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Order: pulumi.String("string"),
    									ProcessQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetQueryTableDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetQueryTableDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									TextFormats: datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatArray{
    										&datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs{
    											TextFormats: datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs{
    													Match: &datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs{
    														Type:  pulumi.String("string"),
    														Value: pulumi.String("string"),
    													},
    													CustomBgColor: pulumi.String("string"),
    													CustomFgColor: pulumi.String("string"),
    													Palette:       pulumi.String("string"),
    													Replace: &datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs{
    														Type:      pulumi.String("string"),
    														With:      pulumi.String("string"),
    														Substring: pulumi.String("string"),
    													},
    												},
    											},
    										},
    									},
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						QueryValueDefinition: &datadog.DashboardWidgetQueryValueDefinitionArgs{
    							Autoscale: pulumi.Bool(false),
    							CustomLinks: datadog.DashboardWidgetQueryValueDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetQueryValueDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							CustomUnit: pulumi.String("string"),
    							LiveSpan:   pulumi.String("string"),
    							Precision:  pulumi.Int(0),
    							Requests: datadog.DashboardWidgetQueryValueDefinitionRequestArray{
    								&datadog.DashboardWidgetQueryValueDefinitionRequestArgs{
    									Aggregator: pulumi.String("string"),
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									AuditQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArray{
    											&datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArray{
    											&datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ConditionalFormats: datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArray{
    										&datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs{
    											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.DashboardWidgetQueryValueDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetQueryValueDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											ConditionalFormats: datadog.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ProcessQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetQueryValueDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetQueryValueDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    								},
    							},
    							TextAlign: pulumi.String("string"),
    							TimeseriesBackground: &datadog.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs{
    								Type: pulumi.String("string"),
    								Yaxis: &datadog.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs{
    									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.DashboardWidgetRunWorkflowDefinitionArgs{
    							WorkflowId: pulumi.String("string"),
    							CustomLinks: datadog.DashboardWidgetRunWorkflowDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetRunWorkflowDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Inputs: datadog.DashboardWidgetRunWorkflowDefinitionInputTypeArray{
    								&datadog.DashboardWidgetRunWorkflowDefinitionInputTypeArgs{
    									Name:  pulumi.String("string"),
    									Value: pulumi.String("string"),
    								},
    							},
    							LiveSpan:   pulumi.String("string"),
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						ScatterplotDefinition: &datadog.DashboardWidgetScatterplotDefinitionArgs{
    							ColorByGroups: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							CustomLinks: datadog.DashboardWidgetScatterplotDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetScatterplotDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							LiveSpan: pulumi.String("string"),
    							Request: &datadog.DashboardWidgetScatterplotDefinitionRequestArgs{
    								ScatterplotTables: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArray{
    									&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs{
    										Formulas: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArray{
    											&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs{
    												Dimension:         pulumi.String("string"),
    												FormulaExpression: pulumi.String("string"),
    												Alias:             pulumi.String("string"),
    											},
    										},
    										Queries: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArray{
    											&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs{
    												ApmDependencyStatsQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs{
    													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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs{
    													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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs{
    													DataSource:    pulumi.String("string"),
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    												},
    												EventQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs{
    													Computes: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArray{
    														&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs{
    															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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArray{
    														&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															Sort: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs{
    																Aggregation: pulumi.String("string"),
    																Metric:      pulumi.String("string"),
    																Order:       pulumi.String("string"),
    															},
    														},
    													},
    													Indexes: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Search: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs{
    														Query: pulumi.String("string"),
    													},
    													Storage: pulumi.String("string"),
    												},
    												MetricQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs{
    													Name:          pulumi.String("string"),
    													Query:         pulumi.String("string"),
    													Aggregator:    pulumi.String("string"),
    													CrossOrgUuids: pulumi.String("string"),
    													DataSource:    pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs{
    													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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs{
    													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"),
    												},
    											},
    										},
    									},
    								},
    								Xes: datadog.DashboardWidgetScatterplotDefinitionRequestXArray{
    									&datadog.DashboardWidgetScatterplotDefinitionRequestXArgs{
    										Aggregator: pulumi.String("string"),
    										ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    												&datadog.DashboardWidgetApmQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    												&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    												&datadog.DashboardWidgetLogQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    												&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs{
    											Metric: pulumi.String("string"),
    											FilterBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit:    pulumi.Int(0),
    											SearchBy: pulumi.String("string"),
    										},
    										Q: pulumi.String("string"),
    										RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    												&datadog.DashboardWidgetRumQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    												&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    												&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    												&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    									},
    								},
    								Ys: datadog.DashboardWidgetScatterplotDefinitionRequestYArray{
    									&datadog.DashboardWidgetScatterplotDefinitionRequestYArgs{
    										Aggregator: pulumi.String("string"),
    										ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    												&datadog.DashboardWidgetApmQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    												&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    												&datadog.DashboardWidgetLogQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    												&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs{
    											Metric: pulumi.String("string"),
    											FilterBies: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											Limit:    pulumi.Int(0),
    											SearchBy: pulumi.String("string"),
    										},
    										Q: pulumi.String("string"),
    										RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    												&datadog.DashboardWidgetRumQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    												&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    										SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    											Index: pulumi.String("string"),
    											ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    											GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    												&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    													Facet: pulumi.String("string"),
    													Limit: pulumi.Int(0),
    													SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Order:       pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    													},
    												},
    											},
    											MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    												&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    											},
    											SearchQuery: pulumi.String("string"),
    										},
    									},
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    							Xaxis: &datadog.DashboardWidgetScatterplotDefinitionXaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    							Yaxis: &datadog.DashboardWidgetScatterplotDefinitionYaxisArgs{
    								IncludeZero: pulumi.Bool(false),
    								Label:       pulumi.String("string"),
    								Max:         pulumi.String("string"),
    								Min:         pulumi.String("string"),
    								Scale:       pulumi.String("string"),
    							},
    						},
    						ServiceLevelObjectiveDefinition: &datadog.DashboardWidgetServiceLevelObjectiveDefinitionArgs{
    							SloId: pulumi.String("string"),
    							TimeWindows: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							ViewMode:               pulumi.String("string"),
    							ViewType:               pulumi.String("string"),
    							AdditionalQueryFilters: pulumi.String("string"),
    							GlobalTimeTarget:       pulumi.String("string"),
    							ShowErrorBudget:        pulumi.Bool(false),
    							Title:                  pulumi.String("string"),
    							TitleAlign:             pulumi.String("string"),
    							TitleSize:              pulumi.String("string"),
    						},
    						ServicemapDefinition: &datadog.DashboardWidgetServicemapDefinitionArgs{
    							Filters: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Service: pulumi.String("string"),
    							CustomLinks: datadog.DashboardWidgetServicemapDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetServicemapDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						SloListDefinition: &datadog.DashboardWidgetSloListDefinitionArgs{
    							Request: &datadog.DashboardWidgetSloListDefinitionRequestArgs{
    								Query: &datadog.DashboardWidgetSloListDefinitionRequestQueryArgs{
    									QueryString: pulumi.String("string"),
    									Limit:       pulumi.Int(0),
    									Sort: &datadog.DashboardWidgetSloListDefinitionRequestQuerySortArgs{
    										Column: pulumi.String("string"),
    										Order:  pulumi.String("string"),
    									},
    								},
    								RequestType: pulumi.String("string"),
    							},
    							Title:      pulumi.String("string"),
    							TitleAlign: pulumi.String("string"),
    							TitleSize:  pulumi.String("string"),
    						},
    						SplitGraphDefinition: &datadog.DashboardWidgetSplitGraphDefinitionArgs{
    							Size: pulumi.String("string"),
    							SourceWidgetDefinition: &datadog.DashboardWidgetSplitGraphDefinitionSourceWidgetDefinitionArgs{
    								ChangeDefinition: &datadog.DashboardWidgetChangeDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetChangeDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetChangeDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									LiveSpan: pulumi.String("string"),
    									Requests: datadog.DashboardWidgetChangeDefinitionRequestArray{
    										&datadog.DashboardWidgetChangeDefinitionRequestArgs{
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ChangeType: pulumi.String("string"),
    											CompareTo:  pulumi.String("string"),
    											Formulas: datadog.DashboardWidgetChangeDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetChangeDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetChangeDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											IncreaseGood: pulumi.Bool(false),
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											OrderBy:  pulumi.String("string"),
    											OrderDir: pulumi.String("string"),
    											ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetChangeDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetChangeDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ShowPresent: pulumi.Bool(false),
    										},
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    								},
    								GeomapDefinition: &datadog.DashboardWidgetGeomapDefinitionArgs{
    									View: &datadog.DashboardWidgetGeomapDefinitionViewArgs{
    										Focus: pulumi.String("string"),
    									},
    									CustomLinks: datadog.DashboardWidgetGeomapDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetGeomapDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									LiveSpan: pulumi.String("string"),
    									Requests: datadog.DashboardWidgetGeomapDefinitionRequestArray{
    										&datadog.DashboardWidgetGeomapDefinitionRequestArgs{
    											Formulas: datadog.DashboardWidgetGeomapDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetGeomapDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetGeomapDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetGeomapDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    										},
    									},
    									Style: &datadog.DashboardWidgetGeomapDefinitionStyleArgs{
    										Palette:     pulumi.String("string"),
    										PaletteFlip: pulumi.Bool(false),
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    								},
    								QueryTableDefinition: &datadog.DashboardWidgetQueryTableDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetQueryTableDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetQueryTableDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									HasSearchBar: pulumi.String("string"),
    									LiveSpan:     pulumi.String("string"),
    									Requests: datadog.DashboardWidgetQueryTableDefinitionRequestArray{
    										&datadog.DashboardWidgetQueryTableDefinitionRequestArgs{
    											Aggregator: pulumi.String("string"),
    											Alias:      pulumi.String("string"),
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ApmStatsQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryArgs{
    												Env:        pulumi.String("string"),
    												Name:       pulumi.String("string"),
    												PrimaryTag: pulumi.String("string"),
    												RowType:    pulumi.String("string"),
    												Service:    pulumi.String("string"),
    												Columns: datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArray{
    													&datadog.DashboardWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs{
    														Name:            pulumi.String("string"),
    														Alias:           pulumi.String("string"),
    														CellDisplayMode: pulumi.String("string"),
    														Order:           pulumi.String("string"),
    													},
    												},
    												Resource: pulumi.String("string"),
    											},
    											CellDisplayModes: pulumi.StringArray{
    												pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestConditionalFormatArgs{
    													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.DashboardWidgetQueryTableDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													CellDisplayModeOptions: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaCellDisplayModeOptionsArgs{
    														TrendType: pulumi.String("string"),
    														YScale:    pulumi.String("string"),
    													},
    													ConditionalFormats: datadog.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetQueryTableDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetQueryTableDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											Limit: pulumi.Int(0),
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Order: pulumi.String("string"),
    											ProcessQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetQueryTableDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetQueryTableDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetQueryTableDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											TextFormats: datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatArray{
    												&datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatArgs{
    													TextFormats: datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArray{
    														&datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs{
    															Match: &datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs{
    																Type:  pulumi.String("string"),
    																Value: pulumi.String("string"),
    															},
    															CustomBgColor: pulumi.String("string"),
    															CustomFgColor: pulumi.String("string"),
    															Palette:       pulumi.String("string"),
    															Replace: &datadog.DashboardWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs{
    																Type:      pulumi.String("string"),
    																With:      pulumi.String("string"),
    																Substring: pulumi.String("string"),
    															},
    														},
    													},
    												},
    											},
    										},
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    								},
    								QueryValueDefinition: &datadog.DashboardWidgetQueryValueDefinitionArgs{
    									Autoscale: pulumi.Bool(false),
    									CustomLinks: datadog.DashboardWidgetQueryValueDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetQueryValueDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									CustomUnit: pulumi.String("string"),
    									LiveSpan:   pulumi.String("string"),
    									Precision:  pulumi.Int(0),
    									Requests: datadog.DashboardWidgetQueryValueDefinitionRequestArray{
    										&datadog.DashboardWidgetQueryValueDefinitionRequestArgs{
    											Aggregator: pulumi.String("string"),
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											AuditQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArray{
    													&datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArray{
    													&datadog.DashboardWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArray{
    												&datadog.DashboardWidgetQueryValueDefinitionRequestConditionalFormatArgs{
    													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.DashboardWidgetQueryValueDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetQueryValueDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetQueryValueDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetQueryValueDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetQueryValueDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetQueryValueDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetQueryValueDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetQueryValueDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    										},
    									},
    									TextAlign: pulumi.String("string"),
    									TimeseriesBackground: &datadog.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundArgs{
    										Type: pulumi.String("string"),
    										Yaxis: &datadog.DashboardWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs{
    											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.DashboardWidgetScatterplotDefinitionArgs{
    									ColorByGroups: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									CustomLinks: datadog.DashboardWidgetScatterplotDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetScatterplotDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									LiveSpan: pulumi.String("string"),
    									Request: &datadog.DashboardWidgetScatterplotDefinitionRequestArgs{
    										ScatterplotTables: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArray{
    											&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableArgs{
    												Formulas: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArray{
    													&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs{
    														Dimension:         pulumi.String("string"),
    														FormulaExpression: pulumi.String("string"),
    														Alias:             pulumi.String("string"),
    													},
    												},
    												Queries: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArray{
    													&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs{
    														ApmDependencyStatsQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs{
    															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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs{
    															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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs{
    															DataSource:    pulumi.String("string"),
    															Name:          pulumi.String("string"),
    															Query:         pulumi.String("string"),
    															Aggregator:    pulumi.String("string"),
    															CrossOrgUuids: pulumi.String("string"),
    														},
    														EventQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs{
    															Computes: datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArray{
    																&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs{
    																	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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArray{
    																&datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs{
    																	Facet: pulumi.String("string"),
    																	Limit: pulumi.Int(0),
    																	Sort: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs{
    																		Aggregation: pulumi.String("string"),
    																		Metric:      pulumi.String("string"),
    																		Order:       pulumi.String("string"),
    																	},
    																},
    															},
    															Indexes: pulumi.StringArray{
    																pulumi.String("string"),
    															},
    															Search: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs{
    																Query: pulumi.String("string"),
    															},
    															Storage: pulumi.String("string"),
    														},
    														MetricQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs{
    															Name:          pulumi.String("string"),
    															Query:         pulumi.String("string"),
    															Aggregator:    pulumi.String("string"),
    															CrossOrgUuids: pulumi.String("string"),
    															DataSource:    pulumi.String("string"),
    														},
    														ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs{
    															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.DashboardWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs{
    															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"),
    														},
    													},
    												},
    											},
    										},
    										Xes: datadog.DashboardWidgetScatterplotDefinitionRequestXArray{
    											&datadog.DashboardWidgetScatterplotDefinitionRequestXArgs{
    												Aggregator: pulumi.String("string"),
    												ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    														&datadog.DashboardWidgetApmQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    														&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    														&datadog.DashboardWidgetLogQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    														&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestXProcessQueryArgs{
    													Metric: pulumi.String("string"),
    													FilterBies: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit:    pulumi.Int(0),
    													SearchBy: pulumi.String("string"),
    												},
    												Q: pulumi.String("string"),
    												RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    														&datadog.DashboardWidgetRumQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    														&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    														&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    														&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    											},
    										},
    										Ys: datadog.DashboardWidgetScatterplotDefinitionRequestYArray{
    											&datadog.DashboardWidgetScatterplotDefinitionRequestYArgs{
    												Aggregator: pulumi.String("string"),
    												ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    														&datadog.DashboardWidgetApmQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    														&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    														&datadog.DashboardWidgetLogQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    														&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												ProcessQuery: &datadog.DashboardWidgetScatterplotDefinitionRequestYProcessQueryArgs{
    													Metric: pulumi.String("string"),
    													FilterBies: pulumi.StringArray{
    														pulumi.String("string"),
    													},
    													Limit:    pulumi.Int(0),
    													SearchBy: pulumi.String("string"),
    												},
    												Q: pulumi.String("string"),
    												RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    														&datadog.DashboardWidgetRumQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    														&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    												SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    													Index: pulumi.String("string"),
    													ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    													GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    														&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    															Facet: pulumi.String("string"),
    															Limit: pulumi.Int(0),
    															SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    																Aggregation: pulumi.String("string"),
    																Order:       pulumi.String("string"),
    																Facet:       pulumi.String("string"),
    															},
    														},
    													},
    													MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    														&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    															Aggregation: pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    															Interval:    pulumi.Int(0),
    														},
    													},
    													SearchQuery: pulumi.String("string"),
    												},
    											},
    										},
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    									Xaxis: &datadog.DashboardWidgetScatterplotDefinitionXaxisArgs{
    										IncludeZero: pulumi.Bool(false),
    										Label:       pulumi.String("string"),
    										Max:         pulumi.String("string"),
    										Min:         pulumi.String("string"),
    										Scale:       pulumi.String("string"),
    									},
    									Yaxis: &datadog.DashboardWidgetScatterplotDefinitionYaxisArgs{
    										IncludeZero: pulumi.Bool(false),
    										Label:       pulumi.String("string"),
    										Max:         pulumi.String("string"),
    										Min:         pulumi.String("string"),
    										Scale:       pulumi.String("string"),
    									},
    								},
    								SunburstDefinition: &datadog.DashboardWidgetSunburstDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetSunburstDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetSunburstDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									HideTotal: pulumi.Bool(false),
    									LegendInline: &datadog.DashboardWidgetSunburstDefinitionLegendInlineArgs{
    										Type:        pulumi.String("string"),
    										HidePercent: pulumi.Bool(false),
    										HideValue:   pulumi.Bool(false),
    									},
    									LegendTable: &datadog.DashboardWidgetSunburstDefinitionLegendTableArgs{
    										Type: pulumi.String("string"),
    									},
    									LiveSpan: pulumi.String("string"),
    									Requests: datadog.DashboardWidgetSunburstDefinitionRequestArray{
    										&datadog.DashboardWidgetSunburstDefinitionRequestArgs{
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											AuditQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Formulas: datadog.DashboardWidgetSunburstDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetSunburstDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											NetworkQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetSunburstDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetSunburstDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Style: &datadog.DashboardWidgetSunburstDefinitionRequestStyleArgs{
    												Palette: pulumi.String("string"),
    											},
    										},
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    								},
    								TimeseriesDefinition: &datadog.DashboardWidgetTimeseriesDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetTimeseriesDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									Events: datadog.DashboardWidgetTimeseriesDefinitionEventArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionEventArgs{
    											Q:             pulumi.String("string"),
    											TagsExecution: pulumi.String("string"),
    										},
    									},
    									LegendColumns: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									LegendLayout: pulumi.String("string"),
    									LegendSize:   pulumi.String("string"),
    									LiveSpan:     pulumi.String("string"),
    									Markers: datadog.DashboardWidgetTimeseriesDefinitionMarkerArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionMarkerArgs{
    											Value:       pulumi.String("string"),
    											DisplayType: pulumi.String("string"),
    											Label:       pulumi.String("string"),
    										},
    									},
    									Requests: datadog.DashboardWidgetTimeseriesDefinitionRequestArray{
    										&datadog.DashboardWidgetTimeseriesDefinitionRequestArgs{
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											AuditQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArray{
    													&datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArray{
    													&datadog.DashboardWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											DisplayType: pulumi.String("string"),
    											Formulas: datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetTimeseriesDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetTimeseriesDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Metadatas: datadog.DashboardWidgetTimeseriesDefinitionRequestMetadataArray{
    												&datadog.DashboardWidgetTimeseriesDefinitionRequestMetadataArgs{
    													Expression: pulumi.String("string"),
    													AliasName:  pulumi.String("string"),
    												},
    											},
    											NetworkQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArray{
    													&datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArray{
    													&datadog.DashboardWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											OnRightYaxis: pulumi.Bool(false),
    											ProcessQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetTimeseriesDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Style: &datadog.DashboardWidgetTimeseriesDefinitionRequestStyleArgs{
    												LineType:  pulumi.String("string"),
    												LineWidth: pulumi.String("string"),
    												Palette:   pulumi.String("string"),
    											},
    										},
    									},
    									RightYaxis: &datadog.DashboardWidgetTimeseriesDefinitionRightYaxisArgs{
    										IncludeZero: pulumi.Bool(false),
    										Label:       pulumi.String("string"),
    										Max:         pulumi.String("string"),
    										Min:         pulumi.String("string"),
    										Scale:       pulumi.String("string"),
    									},
    									ShowLegend: pulumi.Bool(false),
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    									Yaxis: &datadog.DashboardWidgetTimeseriesDefinitionYaxisArgs{
    										IncludeZero: pulumi.Bool(false),
    										Label:       pulumi.String("string"),
    										Max:         pulumi.String("string"),
    										Min:         pulumi.String("string"),
    										Scale:       pulumi.String("string"),
    									},
    								},
    								ToplistDefinition: &datadog.DashboardWidgetToplistDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetToplistDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetToplistDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									LiveSpan: pulumi.String("string"),
    									Requests: datadog.DashboardWidgetToplistDefinitionRequestArray{
    										&datadog.DashboardWidgetToplistDefinitionRequestArgs{
    											ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    													&datadog.DashboardWidgetApmQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    													&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											AuditQuery: &datadog.DashboardWidgetToplistDefinitionRequestAuditQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArray{
    													&datadog.DashboardWidgetToplistDefinitionRequestAuditQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArray{
    													&datadog.DashboardWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ConditionalFormats: datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArray{
    												&datadog.DashboardWidgetToplistDefinitionRequestConditionalFormatArgs{
    													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.DashboardWidgetToplistDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetToplistDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetToplistDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetToplistDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetToplistDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetToplistDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    													&datadog.DashboardWidgetLogQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    													&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetToplistDefinitionRequestProcessQueryArgs{
    												Metric: pulumi.String("string"),
    												FilterBies: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Limit:    pulumi.Int(0),
    												SearchBy: pulumi.String("string"),
    											},
    											Q: pulumi.String("string"),
    											Queries: datadog.DashboardWidgetToplistDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetToplistDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetToplistDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetToplistDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetToplistDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetToplistDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetToplistDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetToplistDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetToplistDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    											RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    													&datadog.DashboardWidgetRumQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    													&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    												Index: pulumi.String("string"),
    												ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    													Interval:    pulumi.Int(0),
    												},
    												GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    													&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    															Aggregation: pulumi.String("string"),
    															Order:       pulumi.String("string"),
    															Facet:       pulumi.String("string"),
    														},
    													},
    												},
    												MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    													&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    														Aggregation: pulumi.String("string"),
    														Facet:       pulumi.String("string"),
    														Interval:    pulumi.Int(0),
    													},
    												},
    												SearchQuery: pulumi.String("string"),
    											},
    											Style: &datadog.DashboardWidgetToplistDefinitionRequestStyleArgs{
    												Palette: pulumi.String("string"),
    											},
    										},
    									},
    									Styles: datadog.DashboardWidgetToplistDefinitionStyleArray{
    										&datadog.DashboardWidgetToplistDefinitionStyleArgs{
    											Displays: datadog.DashboardWidgetToplistDefinitionStyleDisplayArray{
    												&datadog.DashboardWidgetToplistDefinitionStyleDisplayArgs{
    													Type: pulumi.String("string"),
    												},
    											},
    											Palette: pulumi.String("string"),
    											Scaling: pulumi.String("string"),
    										},
    									},
    									Title:      pulumi.String("string"),
    									TitleAlign: pulumi.String("string"),
    									TitleSize:  pulumi.String("string"),
    								},
    								TreemapDefinition: &datadog.DashboardWidgetTreemapDefinitionArgs{
    									CustomLinks: datadog.DashboardWidgetTreemapDefinitionCustomLinkArray{
    										&datadog.DashboardWidgetTreemapDefinitionCustomLinkArgs{
    											IsHidden:      pulumi.Bool(false),
    											Label:         pulumi.String("string"),
    											Link:          pulumi.String("string"),
    											OverrideLabel: pulumi.String("string"),
    										},
    									},
    									Requests: datadog.DashboardWidgetTreemapDefinitionRequestArray{
    										&datadog.DashboardWidgetTreemapDefinitionRequestArgs{
    											Formulas: datadog.DashboardWidgetTreemapDefinitionRequestFormulaArray{
    												&datadog.DashboardWidgetTreemapDefinitionRequestFormulaArgs{
    													FormulaExpression: pulumi.String("string"),
    													Alias:             pulumi.String("string"),
    													CellDisplayMode:   pulumi.String("string"),
    													ConditionalFormats: datadog.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArray{
    														&datadog.DashboardWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs{
    															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.DashboardWidgetTreemapDefinitionRequestFormulaLimitArgs{
    														Count: pulumi.Int(0),
    														Order: pulumi.String("string"),
    													},
    													NumberFormat: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatArgs{
    														Unit: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitArgs{
    															Canonical: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    																UnitName:    pulumi.String("string"),
    																PerUnitName: pulumi.String("string"),
    															},
    															Custom: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    																Label: pulumi.String("string"),
    															},
    														},
    														UnitScale: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    															UnitName: pulumi.String("string"),
    														},
    													},
    													Style: &datadog.DashboardWidgetTreemapDefinitionRequestFormulaStyleArgs{
    														Palette:      pulumi.String("string"),
    														PaletteIndex: pulumi.Int(0),
    													},
    												},
    											},
    											Queries: datadog.DashboardWidgetTreemapDefinitionRequestQueryArray{
    												&datadog.DashboardWidgetTreemapDefinitionRequestQueryArgs{
    													ApmDependencyStatsQuery: &datadog.DashboardWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    														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.DashboardWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs{
    														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.DashboardWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs{
    														DataSource:    pulumi.String("string"),
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    													},
    													EventQuery: &datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQueryArgs{
    														Computes: datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArray{
    															&datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs{
    																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.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArray{
    															&datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs{
    																Facet: pulumi.String("string"),
    																Limit: pulumi.Int(0),
    																Sort: &datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs{
    																	Aggregation: pulumi.String("string"),
    																	Metric:      pulumi.String("string"),
    																	Order:       pulumi.String("string"),
    																},
    															},
    														},
    														Indexes: pulumi.StringArray{
    															pulumi.String("string"),
    														},
    														Search: &datadog.DashboardWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs{
    															Query: pulumi.String("string"),
    														},
    														Storage: pulumi.String("string"),
    													},
    													MetricQuery: &datadog.DashboardWidgetTreemapDefinitionRequestQueryMetricQueryArgs{
    														Name:          pulumi.String("string"),
    														Query:         pulumi.String("string"),
    														Aggregator:    pulumi.String("string"),
    														CrossOrgUuids: pulumi.String("string"),
    														DataSource:    pulumi.String("string"),
    													},
    													ProcessQuery: &datadog.DashboardWidgetTreemapDefinitionRequestQueryProcessQueryArgs{
    														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.DashboardWidgetTreemapDefinitionRequestQuerySloQueryArgs{
    														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"),
    													},
    												},
    											},
    										},
    									},
    									Title: pulumi.String("string"),
    								},
    							},
    							SplitConfig: &datadog.DashboardWidgetSplitGraphDefinitionSplitConfigArgs{
    								Sort: &datadog.DashboardWidgetSplitGraphDefinitionSplitConfigSortArgs{
    									Order: pulumi.String("string"),
    									Compute: &datadog.DashboardWidgetSplitGraphDefinitionSplitConfigSortComputeArgs{
    										Metric:      pulumi.String("string"),
    										Aggregation: pulumi.String("string"),
    									},
    								},
    								SplitDimensions: &datadog.DashboardWidgetSplitGraphDefinitionSplitConfigSplitDimensionsArgs{
    									OneGraphPer: pulumi.String("string"),
    								},
    								Limit: pulumi.Int(0),
    								StaticSplits: datadog.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitArray{
    									&datadog.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitArgs{
    										SplitVectors: datadog.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArray{
    											&datadog.DashboardWidgetSplitGraphDefinitionSplitConfigStaticSplitSplitVectorArgs{
    												TagKey: pulumi.String("string"),
    												TagValues: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    											},
    										},
    									},
    								},
    							},
    							HasUniformYAxes: pulumi.Bool(false),
    							LiveSpan:        pulumi.String("string"),
    							Title:           pulumi.String("string"),
    						},
    						SunburstDefinition: &datadog.DashboardWidgetSunburstDefinitionArgs{
    							CustomLinks: datadog.DashboardWidgetSunburstDefinitionCustomLinkArray{
    								&datadog.DashboardWidgetSunburstDefinitionCustomLinkArgs{
    									IsHidden:      pulumi.Bool(false),
    									Label:         pulumi.String("string"),
    									Link:          pulumi.String("string"),
    									OverrideLabel: pulumi.String("string"),
    								},
    							},
    							HideTotal: pulumi.Bool(false),
    							LegendInline: &datadog.DashboardWidgetSunburstDefinitionLegendInlineArgs{
    								Type:        pulumi.String("string"),
    								HidePercent: pulumi.Bool(false),
    								HideValue:   pulumi.Bool(false),
    							},
    							LegendTable: &datadog.DashboardWidgetSunburstDefinitionLegendTableArgs{
    								Type: pulumi.String("string"),
    							},
    							LiveSpan: pulumi.String("string"),
    							Requests: datadog.DashboardWidgetSunburstDefinitionRequestArray{
    								&datadog.DashboardWidgetSunburstDefinitionRequestArgs{
    									ApmQuery: &datadog.DashboardWidgetApmQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetApmQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetApmQueryGroupByArray{
    											&datadog.DashboardWidgetApmQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetApmQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetApmQueryMultiComputeArray{
    											&datadog.DashboardWidgetApmQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									AuditQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArray{
    											&datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArray{
    											&datadog.DashboardWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									Formulas: datadog.DashboardWidgetSunburstDefinitionRequestFormulaArray{
    										&datadog.DashboardWidgetSunburstDefinitionRequestFormulaArgs{
    											FormulaExpression: pulumi.String("string"),
    											Alias:             pulumi.String("string"),
    											CellDisplayMode:   pulumi.String("string"),
    											ConditionalFormats: datadog.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArray{
    												&datadog.DashboardWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs{
    													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.DashboardWidgetSunburstDefinitionRequestFormulaLimitArgs{
    												Count: pulumi.Int(0),
    												Order: pulumi.String("string"),
    											},
    											NumberFormat: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatArgs{
    												Unit: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitArgs{
    													Canonical: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCanonicalArgs{
    														UnitName:    pulumi.String("string"),
    														PerUnitName: pulumi.String("string"),
    													},
    													Custom: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitCustomArgs{
    														Label: pulumi.String("string"),
    													},
    												},
    												UnitScale: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaNumberFormatUnitScaleArgs{
    													UnitName: pulumi.String("string"),
    												},
    											},
    											Style: &datadog.DashboardWidgetSunburstDefinitionRequestFormulaStyleArgs{
    												Palette:      pulumi.String("string"),
    												PaletteIndex: pulumi.Int(0),
    											},
    										},
    									},
    									LogQuery: &datadog.DashboardWidgetLogQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetLogQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetLogQueryGroupByArray{
    											&datadog.DashboardWidgetLogQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetLogQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetLogQueryMultiComputeArray{
    											&datadog.DashboardWidgetLogQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									NetworkQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArray{
    											&datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArray{
    											&datadog.DashboardWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									ProcessQuery: &datadog.DashboardWidgetSunburstDefinitionRequestProcessQueryArgs{
    										Metric: pulumi.String("string"),
    										FilterBies: pulumi.StringArray{
    											pulumi.String("string"),
    										},
    										Limit:    pulumi.Int(0),
    										SearchBy: pulumi.String("string"),
    									},
    									Q: pulumi.String("string"),
    									Queries: datadog.DashboardWidgetSunburstDefinitionRequestQueryArray{
    										&datadog.DashboardWidgetSunburstDefinitionRequestQueryArgs{
    											ApmDependencyStatsQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs{
    												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.DashboardWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs{
    												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.DashboardWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs{
    												DataSource:    pulumi.String("string"),
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    											},
    											EventQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryArgs{
    												Computes: datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs{
    														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.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArray{
    													&datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs{
    														Facet: pulumi.String("string"),
    														Limit: pulumi.Int(0),
    														Sort: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs{
    															Aggregation: pulumi.String("string"),
    															Metric:      pulumi.String("string"),
    															Order:       pulumi.String("string"),
    														},
    													},
    												},
    												Indexes: pulumi.StringArray{
    													pulumi.String("string"),
    												},
    												Search: &datadog.DashboardWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs{
    													Query: pulumi.String("string"),
    												},
    												Storage: pulumi.String("string"),
    											},
    											MetricQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryMetricQueryArgs{
    												Name:          pulumi.String("string"),
    												Query:         pulumi.String("string"),
    												Aggregator:    pulumi.String("string"),
    												CrossOrgUuids: pulumi.String("string"),
    												DataSource:    pulumi.String("string"),
    											},
    											ProcessQuery: &datadog.DashboardWidgetSunburstDefinitionRequestQueryProcessQueryArgs{
    												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.DashboardWidgetSunburstDefinitionRequestQuerySloQueryArgs{
    												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"),
    											},
    										},
    									},
    									RumQuery: &datadog.DashboardWidgetRumQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetRumQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetRumQueryGroupByArray{
    											&datadog.DashboardWidgetRumQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetRumQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetRumQueryMultiComputeArray{
    											&datadog.DashboardWidgetRumQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0),
    											},
    										},
    										SearchQuery: pulumi.String("string"),
    									},
    									SecurityQuery: &datadog.DashboardWidgetSecurityQueryArgs{
    										Index: pulumi.String("string"),
    										ComputeQuery: &datadog.DashboardWidgetSecurityQueryComputeQueryArgs{
    											Aggregation: pulumi.String("string"),
    											Facet:       pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    										},
    										GroupBies: datadog.DashboardWidgetSecurityQueryGroupByArray{
    											&datadog.DashboardWidgetSecurityQueryGroupByArgs{
    												Facet: pulumi.String("string"),
    												Limit: pulumi.Int(0),
    												SortQuery: &datadog.DashboardWidgetSecurityQueryGroupBySortQueryArgs{
    													Aggregation: pulumi.String("string"),
    													Order:       pulumi.String("string"),
    													Facet:       pulumi.String("string"),
    												},
    											},
    										},
    										MultiComputes: datadog.DashboardWidgetSecurityQueryMultiComputeArray{
    											&datadog.DashboardWidgetSecurityQueryMultiComputeArgs{
    												Aggregation: pulumi.String("string"),
    												Facet:       pulumi.String("string"),
    												Interval:    pulumi.Int(0