1. Packages
  2. Datadog
  3. API Docs
  4. Dashboard
Datadog v4.27.0 published on Thursday, Mar 14, 2024 by Pulumi

datadog.Dashboard

Explore with Pulumi AI

datadog logo
Datadog v4.27.0 published on Thursday, Mar 14, 2024 by Pulumi

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

    Example Usage

    Coming soon!
    
    Coming soon!
    
    Coming soon!
    
    Coming soon!
    
    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.DashboardTemplateVariableArgs;
    import com.pulumi.datadog.inputs.DashboardTemplateVariablePresetArgs;
    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.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) {
            var orderedDashboard = new Dashboard("orderedDashboard", DashboardArgs.builder()        
                .description("Created using the Datadog provider in Pulumi")
                .isReadOnly(true)
                .layoutType("ordered")
                .templateVariables(            
                    DashboardTemplateVariableArgs.builder()
                        .default_("aws")
                        .name("var_1")
                        .prefix("host")
                        .build(),
                    DashboardTemplateVariableArgs.builder()
                        .default_("autoscaling")
                        .name("var_2")
                        .prefix("service_name")
                        .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())
                .title("Ordered Layout Dashboard")
                .widgets(            
                    DashboardWidgetArgs.builder()
                        .alertGraphDefinition(DashboardWidgetAlertGraphDefinitionArgs.builder()
                            .alertId("895605")
                            .liveSpan("1h")
                            .title("Widget Title")
                            .vizType("timeseries")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .alertValueDefinition(DashboardWidgetAlertValueDefinitionArgs.builder()
                            .alertId("895605")
                            .precision(3)
                            .textAlign("center")
                            .title("Widget Title")
                            .unit("b")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .alertValueDefinition(DashboardWidgetAlertValueDefinitionArgs.builder()
                            .alertId("895605")
                            .precision(3)
                            .textAlign("center")
                            .title("Widget Title")
                            .unit("b")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .changeDefinition(DashboardWidgetChangeDefinitionArgs.builder()
                            .liveSpan("1h")
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .distributionDefinition(DashboardWidgetDistributionDefinitionArgs.builder()
                            .liveSpan("1h")
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .checkStatusDefinition(DashboardWidgetCheckStatusDefinitionArgs.builder()
                            .check("aws.ecs.agent_connected")
                            .groupBy(                        
                                "account",
                                "cluster")
                            .grouping("cluster")
                            .liveSpan("1h")
                            .tags(                        
                                "account:demo",
                                "cluster:awseb-ruthebdog-env-8-dn3m6u3gvk")
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .heatmapDefinition(DashboardWidgetHeatmapDefinitionArgs.builder()
                            .liveSpan("1h")
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .title("Widget Title")
                            .yaxis(DashboardWidgetHeatmapDefinitionYaxisArgs.builder()
                                .includeZero(true)
                                .max(2)
                                .min(1)
                                .scale("sqrt")
                                .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .hostmapDefinition(DashboardWidgetHostmapDefinitionArgs.builder()
                            .group(                        
                                "host",
                                "region")
                            .noGroupHosts(true)
                            .noMetricHosts(true)
                            .nodeType("container")
                            .request(DashboardWidgetHostmapDefinitionRequestArgs.builder()
                                .fill(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .size(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .build())
                            .scope(                        
                                "region:us-east-1",
                                "aws_account:727006795293")
                            .style(DashboardWidgetHostmapDefinitionStyleArgs.builder()
                                .fillMax("20")
                                .fillMin("10")
                                .palette("yellow_to_green")
                                .paletteFlip(true)
                                .build())
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .noteDefinition(DashboardWidgetNoteDefinitionArgs.builder()
                            .backgroundColor("pink")
                            .content("note text")
                            .fontSize("14")
                            .showTick(true)
                            .textAlign("center")
                            .tickEdge("left")
                            .tickPos("50%")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .queryValueDefinition(DashboardWidgetQueryValueDefinitionArgs.builder()
                            .autoscale(true)
                            .customUnit("xx")
                            .liveSpan("1h")
                            .precision("4")
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .textAlign("right")
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .queryTableDefinition(DashboardWidgetQueryTableDefinitionArgs.builder()
                            .liveSpan("1h")
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .scatterplotDefinition(DashboardWidgetScatterplotDefinitionArgs.builder()
                            .colorByGroups(                        
                                "account",
                                "apm-role-group")
                            .liveSpan("1h")
                            .request(DashboardWidgetScatterplotDefinitionRequestArgs.builder()
                                .x(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .y(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .build())
                            .title("Widget Title")
                            .xaxis(DashboardWidgetScatterplotDefinitionXaxisArgs.builder()
                                .includeZero(true)
                                .label("x")
                                .max("2000")
                                .min("1")
                                .scale("pow")
                                .build())
                            .yaxis(DashboardWidgetScatterplotDefinitionYaxisArgs.builder()
                                .includeZero(false)
                                .label("y")
                                .max("2222")
                                .min("5")
                                .scale("log")
                                .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .servicemapDefinition(DashboardWidgetServicemapDefinitionArgs.builder()
                            .filters(                        
                                "env:prod",
                                "datacenter:dc1")
                            .service("master-db")
                            .title("env: prod, datacenter:dc1, service: master-db")
                            .titleAlign("left")
                            .titleSize("16")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .event(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .legendSize("2")
                            .liveSpan("1h")
                            .marker(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .request(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .showLegend(true)
                            .title("Widget Title")
                            .yaxis(DashboardWidgetTimeseriesDefinitionYaxisArgs.builder()
                                .includeZero(false)
                                .max(100)
                                .scale("log")
                                .build())
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .toplistDefinition(DashboardWidgetToplistDefinitionArgs.builder()
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .title("Widget Title")
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .groupDefinition(DashboardWidgetGroupDefinitionArgs.builder()
                            .layoutType("ordered")
                            .title("Group Widget")
                            .widget(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .serviceLevelObjectiveDefinition(DashboardWidgetServiceLevelObjectiveDefinitionArgs.builder()
                            .showErrorBudget(true)
                            .sloId("56789")
                            .timeWindows(                        
                                "7d",
                                "previous_week")
                            .title("Widget Title")
                            .viewMode("overall")
                            .viewType("detail")
                            .build())
                        .build())
                .build());
    
            var freeDashboard = new Dashboard("freeDashboard", DashboardArgs.builder()        
                .description("Created using the Datadog provider in Pulumi")
                .isReadOnly(false)
                .layoutType("free")
                .templateVariables(            
                    DashboardTemplateVariableArgs.builder()
                        .default_("aws")
                        .name("var_1")
                        .prefix("host")
                        .build(),
                    DashboardTemplateVariableArgs.builder()
                        .default_("autoscaling")
                        .name("var_2")
                        .prefix("service_name")
                        .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())
                .title("Free Layout Dashboard")
                .widgets(            
                    DashboardWidgetArgs.builder()
                        .eventStreamDefinition(DashboardWidgetEventStreamDefinitionArgs.builder()
                            .eventSize("l")
                            .liveSpan("1h")
                            .query("*")
                            .title("Widget Title")
                            .titleAlign("left")
                            .titleSize(16)
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(43)
                            .width(32)
                            .x(0)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .eventTimelineDefinition(DashboardWidgetEventTimelineDefinitionArgs.builder()
                            .liveSpan("1h")
                            .query("*")
                            .title("Widget Title")
                            .titleAlign("left")
                            .titleSize(16)
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(9)
                            .width(66)
                            .x(33)
                            .y(60)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .freeTextDefinition(DashboardWidgetFreeTextDefinitionArgs.builder()
                            .color("#d00")
                            .fontSize("36")
                            .text("free text content")
                            .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()
                            .margin("small")
                            .sizing("fit")
                            .url("https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(20)
                            .width(30)
                            .x(69)
                            .y(0)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .logStreamDefinition(DashboardWidgetLogStreamDefinitionArgs.builder()
                            .columns(                        
                                "core_host",
                                "core_service",
                                "tag_source")
                            .indexes("main")
                            .messageDisplay("expanded-md")
                            .query("error")
                            .showDateColumn(true)
                            .showMessageColumn(true)
                            .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")
                            .titleAlign("left")
                            .titleSize(16)
                            .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")
                            .liveSpan("1h")
                            .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")
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(38)
                            .width(66)
                            .x(33)
                            .y(21)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(25)
                            .x(58)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .request(                        
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference),
                                %!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(28)
                            .x(29)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .widgetLayout(DashboardWidgetWidgetLayoutArgs.builder()
                            .height(16)
                            .width(28)
                            .x(0)
                            .y(83)
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .timeseriesDefinition(DashboardWidgetTimeseriesDefinitionArgs.builder()
                            .request(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                            .build())
                        .build(),
                    DashboardWidgetArgs.builder()
                        .powerpackDefinition(DashboardWidgetPowerpackDefinitionArgs.builder()
                            .backgroundColor("blue")
                            .bannerImg("https://example.org/example.png")
                            .powerpackId("00000000-0000-0000-0000-000000000000")
                            .showTitle(true)
                            .templateVariables(DashboardWidgetPowerpackDefinitionTemplateVariablesArgs.builder()
                                .controlledByPowerpack(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .controlledExternally(%!v(PANIC=Format method: runtime error: invalid memory address or nil pointer dereference))
                                .build())
                            .title("Powerpack Widget")
                            .build())
                        .build())
                .build());
    
        }
    }
    
    resources:
      # Example Ordered Layout
      orderedDashboard:
        type: datadog:Dashboard
        properties:
          description: Created using the Datadog provider in Pulumi
          isReadOnly: true
          layoutType: ordered
          templateVariables:
            - default: aws
              name: var_1
              prefix: host
            - default: autoscaling
              name: var_2
              prefix: service_name
          templateVariablePresets:
            - name: preset_1
              templateVariables:
                - name: var_1
                  value: host.dc
                - name: var_2
                  value: my_service
          title: Ordered Layout Dashboard
          widgets:
            - alertGraphDefinition:
                alertId: '895605'
                liveSpan: 1h
                title: Widget Title
                vizType: timeseries
            - alertValueDefinition:
                alertId: '895605'
                precision: 3
                textAlign: center
                title: Widget Title
                unit: b
            - alertValueDefinition:
                alertId: '895605'
                precision: 3
                textAlign: center
                title: Widget Title
                unit: b
            - changeDefinition:
                liveSpan: 1h
                request:
                  - changeType: absolute
                    compareTo: week_before
                    increaseGood: true
                    orderBy: name
                    orderDir: desc
                    q: avg:system.load.1{env:staging} by {account}
                    showPresent: true
                title: Widget Title
            - distributionDefinition:
                liveSpan: 1h
                request:
                  - q: avg:system.load.1{env:staging} by {account}
                    style:
                      palette: warm
                title: Widget Title
            - checkStatusDefinition:
                check: aws.ecs.agent_connected
                groupBy:
                  - account
                  - cluster
                grouping: cluster
                liveSpan: 1h
                tags:
                  - account:demo
                  - cluster:awseb-ruthebdog-env-8-dn3m6u3gvk
                title: Widget Title
            - heatmapDefinition:
                liveSpan: 1h
                request:
                  - q: avg:system.load.1{env:staging} by {account}
                    style:
                      palette: warm
                title: Widget Title
                yaxis:
                  includeZero: true
                  max: 2
                  min: 1
                  scale: sqrt
            - hostmapDefinition:
                group:
                  - host
                  - region
                noGroupHosts: true
                noMetricHosts: true
                nodeType: container
                request:
                  fill:
                    - q: avg:system.load.1{*} by {host}
                  size:
                    - q: avg:memcache.uptime{*} by {host}
                scope:
                  - region:us-east-1
                  - aws_account:727006795293
                style:
                  fillMax: '20'
                  fillMin: '10'
                  palette: yellow_to_green
                  paletteFlip: true
                title: Widget Title
            - noteDefinition:
                backgroundColor: pink
                content: note text
                fontSize: '14'
                showTick: true
                textAlign: center
                tickEdge: left
                tickPos: 50%
            - queryValueDefinition:
                autoscale: true
                customUnit: xx
                liveSpan: 1h
                precision: '4'
                request:
                  - aggregator: sum
                    conditionalFormats:
                      - comparator: <
                        palette: white_on_green
                        value: '2'
                      - comparator: '>'
                        palette: white_on_red
                        value: '2.2'
                    q: avg:system.load.1{env:staging} by {account}
                textAlign: right
                title: Widget Title
            - queryTableDefinition:
                liveSpan: 1h
                request:
                  - aggregator: sum
                    conditionalFormats:
                      - comparator: <
                        palette: white_on_green
                        value: '2'
                      - comparator: '>'
                        palette: white_on_red
                        value: '2.2'
                    limit: '10'
                    q: avg:system.load.1{env:staging} by {account}
                title: Widget Title
            - scatterplotDefinition:
                colorByGroups:
                  - account
                  - apm-role-group
                liveSpan: 1h
                request:
                  x:
                    - aggregator: max
                      q: avg:system.cpu.user{*} by {service, account}
                  y:
                    - aggregator: min
                      q: avg:system.mem.used{*} by {service, account}
                title: Widget Title
                xaxis:
                  includeZero: true
                  label: x
                  max: '2000'
                  min: '1'
                  scale: pow
                yaxis:
                  includeZero: false
                  label: y
                  max: '2222'
                  min: '5'
                  scale: log
            - servicemapDefinition:
                filters:
                  - env:prod
                  - datacenter:dc1
                service: master-db
                title: 'env: prod, datacenter:dc1, service: master-db'
                titleAlign: left
                titleSize: '16'
            - timeseriesDefinition:
                event:
                  - q: sources:test tags:1
                  - q: sources:test tags:2
                legendSize: '2'
                liveSpan: 1h
                marker:
                  - displayType: error dashed
                    label: ' z=6 '
                    value: y = 4
                  - displayType: ok solid
                    label: ' x=8 '
                    value: 10 < y < 999
                request:
                  - displayType: line
                    metadata:
                      - aliasName: Alpha
                        expression: avg:system.cpu.user{app:general} by {env}
                    q: avg:system.cpu.user{app:general} by {env}
                    style:
                      lineType: dashed
                      lineWidth: thin
                      palette: warm
                  - displayType: area
                    logQuery:
                      computeQuery:
                        aggregation: avg
                        facet: '@duration'
                        interval: 5000
                      groupBy:
                        - facet: host
                          limit: 10
                          sortQuery:
                            aggregation: avg
                            facet: '@duration'
                            order: desc
                      index: mcnulty
                      searchQuery: status:info
                  - apmQuery:
                      computeQuery:
                        aggregation: avg
                        facet: '@duration'
                        interval: 5000
                      groupBy:
                        - facet: resource_name
                          limit: 50
                          sortQuery:
                            aggregation: avg
                            facet: '@string_query.interval'
                            order: desc
                      index: apm-search
                      searchQuery: type:web
                    displayType: bars
                  - displayType: area
                    processQuery:
                      filterBy:
                        - active
                      limit: 50
                      metric: process.stat.cpu.total_pct
                      searchBy: error
                showLegend: true
                title: Widget Title
                yaxis:
                  includeZero: false
                  max: 100
                  scale: log
            - toplistDefinition:
                request:
                  - conditionalFormats:
                      - comparator: <
                        palette: white_on_green
                        value: '2'
                      - comparator: '>'
                        palette: white_on_red
                        value: '2.2'
                    q: avg:system.cpu.user{app:general} by {env}
                title: Widget Title
            - groupDefinition:
                layoutType: ordered
                title: Group Widget
                widget:
                  - noteDefinition:
                      backgroundColor: pink
                      content: cluster note widget
                      fontSize: '14'
                      showTick: true
                      textAlign: center
                      tickEdge: left
                      tickPos: 50%
                  - alertGraphDefinition:
                      alertId: '123'
                      liveSpan: 1h
                      title: Alert Graph
                      vizType: toplist
            - serviceLevelObjectiveDefinition:
                showErrorBudget: true
                sloId: '56789'
                timeWindows:
                  - 7d
                  - previous_week
                title: Widget Title
                viewMode: overall
                viewType: detail
      # Example Free Layout
      freeDashboard:
        type: datadog:Dashboard
        properties:
          description: Created using the Datadog provider in Pulumi
          isReadOnly: false
          layoutType: free
          templateVariables:
            - default: aws
              name: var_1
              prefix: host
            - default: autoscaling
              name: var_2
              prefix: service_name
          templateVariablePresets:
            - name: preset_1
              templateVariables:
                - name: var_1
                  value: host.dc
                - name: var_2
                  value: my_service
          title: Free Layout Dashboard
          widgets:
            - eventStreamDefinition:
                eventSize: l
                liveSpan: 1h
                query: '*'
                title: Widget Title
                titleAlign: left
                titleSize: 16
              widgetLayout:
                height: 43
                width: 32
                x: 0
                y: 0
            - eventTimelineDefinition:
                liveSpan: 1h
                query: '*'
                title: Widget Title
                titleAlign: left
                titleSize: 16
              widgetLayout:
                height: 9
                width: 66
                x: 33
                y: 60
            - freeTextDefinition:
                color: '#d00'
                fontSize: '36'
                text: free text content
                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:
                margin: small
                sizing: fit
                url: https://images.pexels.com/photos/67636/rose-blue-flower-rose-blooms-67636.jpeg?auto=compress&cs=tinysrgb&h=350
              widgetLayout:
                height: 20
                width: 30
                x: 69
                y: 0
            - logStreamDefinition:
                columns:
                  - core_host
                  - core_service
                  - tag_source
                indexes:
                  - main
                messageDisplay: expanded-md
                query: error
                showDateColumn: true
                showMessageColumn: true
                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
                titleAlign: left
                titleSize: 16
              widgetLayout:
                height: 40
                width: 30
                x: 101
                y: 48
            - traceServiceDefinition:
                displayFormat: three_column
                env: datadog.com
                liveSpan: 1h
                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'
              widgetLayout:
                height: 38
                width: 66
                x: 33
                y: 21
            - timeseriesDefinition:
                request:
                  - formula:
                      - alias: my ff query
                        formulaExpression: my_query_1 + my_query_2
                      - alias: my second ff query
                        formulaExpression: my_query_1 * my_query_2
                        limit:
                          count: 5
                          order: desc
                    query:
                      - metricQuery:
                          aggregator: sum
                          dataSource: metrics
                          name: my_query_1
                          query: avg:system.cpu.user{app:general} by {env}
                      - metricQuery:
                          aggregator: sum
                          name: my_query_2
                          query: avg:system.cpu.user{app:general} by {env}
              widgetLayout:
                height: 16
                width: 25
                x: 58
                y: 83
            - timeseriesDefinition:
                request:
                  - query:
                      - eventQuery:
                          compute:
                            - aggregation: count
                          dataSource: logs
                          groupBy:
                            - facet: host
                              limit: 10
                              sort:
                                aggregation: avg
                                metric: '@lambda.max_memory_used'
                          indexes:
                            - days-3
                          name: my-query
                  - displayType: overlay
                    query:
                      - metricQuery:
                          dataSource: metrics
                          name: MyOverlay
                          query: avg:system.cpu.user{host:COMP-QJWVM2FYT4}
              widgetLayout:
                height: 16
                width: 28
                x: 29
                y: 83
            - timeseriesDefinition:
                request:
                  - query:
                      - processQuery:
                          aggregator: sum
                          dataSource: process
                          isNormalizedCpu: true
                          limit: 10
                          metric: process.stat.cpu.total_pct
                          name: my_process_query
                          sort: asc
                          tagFilters:
                            - some_filter
                          textFilter: abc
              widgetLayout:
                height: 16
                width: 28
                x: 0
                y: 83
            - timeseriesDefinition:
                request:
                  - formula:
                      - alias: my cloud cost query
                        formulaExpression: query1
                    query:
                      - cloudCostQuery:
                          aggregator: sum
                          dataSource: cloud_cost
                          name: query1
                          query: sum:aws.cost.amortized{*}
            - powerpackDefinition:
                backgroundColor: blue
                bannerImg: https://example.org/example.png
                powerpackId: 00000000-0000-0000-0000-000000000000
                showTitle: true
                templateVariables:
                  controlledByPowerpack:
                    - name: var_3
                      prefix: timeframe
                      values:
                        - default
                        - values
                        - here
                  controlledExternally:
                    - name: var_2
                      prefix: service_name
                      values:
                        - autoscaling
                title: Powerpack Widget
    

    Create Dashboard Resource

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

    Constructor syntax

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

    Parameters

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

    Example

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

    var dashboardResource = new Datadog.Dashboard("dashboardResource", new()
    {
        LayoutType = "string",
        Title = "string",
        RestrictedRoles = new[]
        {
            "string",
        },
        NotifyLists = new[]
        {
            "string",
        },
        ReflowType = "string",
        DashboardLists = new[]
        {
            0,
        },
        Tags = new[]
        {
            "string",
        },
        TemplateVariablePresets = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariablePresetArgs
            {
                Name = "string",
                TemplateVariables = new[]
                {
                    new Datadog.Inputs.DashboardTemplateVariablePresetTemplateVariableArgs
                    {
                        Name = "string",
                        Values = new[]
                        {
                            "string",
                        },
                    },
                },
            },
        },
        TemplateVariables = new[]
        {
            new Datadog.Inputs.DashboardTemplateVariableArgs
            {
                Name = "string",
                AvailableValues = new[]
                {
                    "string",
                },
                Defaults = new[]
                {
                    "string",
                },
                Prefix = "string",
            },
        },
        Description = "string",
        Url = "string",
        Widgets = new[]
        {
            new Datadog.Inputs.DashboardWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "string",
                    VizType = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                AlertValueDefinition = new Datadog.Inputs.DashboardWidgetAlertValueDefinitionArgs
                {
                    AlertId = "string",
                    Precision = 0,
                    TextAlign = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Unit = "string",
                },
                ChangeDefinition = new Datadog.Inputs.DashboardWidgetChangeDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ChangeType = "string",
                            CompareTo = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            IncreaseGood = false,
                            LogQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OrderBy = "string",
                            OrderDir = "string",
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ShowPresent = false,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetCheckStatusDefinitionArgs
                {
                    Check = "string",
                    Grouping = "string",
                    Group = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    Tags = new[]
                    {
                        "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                DistributionDefinition = new Datadog.Inputs.DashboardWidgetDistributionDefinitionArgs
                {
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            RumQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.DashboardWidgetDistributionDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventStreamDefinition = new Datadog.Inputs.DashboardWidgetEventStreamDefinitionArgs
                {
                    Query = "string",
                    EventSize = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetEventTimelineDefinitionArgs
                {
                    Query = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FreeTextDefinition = new Datadog.Inputs.DashboardWidgetFreeTextDefinitionArgs
                {
                    Text = "string",
                    Color = "string",
                    FontSize = "string",
                    TextAlign = "string",
                },
                GeomapDefinition = new Datadog.Inputs.DashboardWidgetGeomapDefinitionArgs
                {
                    View = new Datadog.Inputs.DashboardWidgetGeomapDefinitionViewArgs
                    {
                        Focus = "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGeomapDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    Style = new Datadog.Inputs.DashboardWidgetGeomapDefinitionStyleArgs
                    {
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                GroupDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionArgs
                {
                    LayoutType = "string",
                    BackgroundColor = "string",
                    BannerImg = "string",
                    ShowTitle = false,
                    Title = "string",
                    Widgets = new[]
                    {
                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetArgs
                        {
                            AlertGraphDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetAlertGraphDefinitionArgs
                            {
                                AlertId = "string",
                                VizType = "string",
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            AlertValueDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetAlertValueDefinitionArgs
                            {
                                AlertId = "string",
                                Precision = 0,
                                TextAlign = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Unit = "string",
                            },
                            ChangeDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ChangeType = "string",
                                        CompareTo = "string",
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        IncreaseGood = false,
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        OrderBy = "string",
                                        OrderDir = "string",
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ShowPresent = false,
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            CheckStatusDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetCheckStatusDefinitionArgs
                            {
                                Check = "string",
                                Grouping = "string",
                                Group = "string",
                                GroupBies = new[]
                                {
                                    "string",
                                },
                                LiveSpan = "string",
                                Tags = new[]
                                {
                                    "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            DistributionDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionArgs
                            {
                                LegendSize = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ApmStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryArgs
                                        {
                                            Env = "string",
                                            Name = "string",
                                            PrimaryTag = "string",
                                            RowType = "string",
                                            Service = "string",
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                                {
                                                    Name = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Resource = "string",
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetDistributionDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            EventStreamDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetEventStreamDefinitionArgs
                            {
                                Query = "string",
                                EventSize = "string",
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            EventTimelineDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetEventTimelineDefinitionArgs
                            {
                                Query = "string",
                                LiveSpan = "string",
                                TagsExecution = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            FreeTextDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetFreeTextDefinitionArgs
                            {
                                Text = "string",
                                Color = "string",
                                FontSize = "string",
                                TextAlign = "string",
                            },
                            GeomapDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionArgs
                            {
                                View = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionViewArgs
                                {
                                    Focus = "string",
                                },
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestArgs
                                    {
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetGeomapDefinitionStyleArgs
                                {
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            HeatmapDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Events = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionEventArgs
                                    {
                                        Q = "string",
                                        TagsExecution = "string",
                                    },
                                },
                                LegendSize = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestArgs
                                    {
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionRequestStyleArgs
                                        {
                                            Palette = "string",
                                        },
                                    },
                                },
                                ShowLegend = false,
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Yaxis = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHeatmapDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            HostmapDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Groups = new[]
                                {
                                    "string",
                                },
                                NoGroupHosts = false,
                                NoMetricHosts = false,
                                NodeType = "string",
                                Request = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestArgs
                                {
                                    Fills = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillArgs
                                        {
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestFillSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                    Sizes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeArgs
                                        {
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionRequestSizeSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                },
                                Scopes = new[]
                                {
                                    "string",
                                },
                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetHostmapDefinitionStyleArgs
                                {
                                    FillMax = "string",
                                    FillMin = "string",
                                    Palette = "string",
                                    PaletteFlip = false,
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            Id = 0,
                            IframeDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetIframeDefinitionArgs
                            {
                                Url = "string",
                            },
                            ImageDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetImageDefinitionArgs
                            {
                                Url = "string",
                                HasBackground = false,
                                HasBorder = false,
                                HorizontalAlign = "string",
                                Margin = "string",
                                Sizing = "string",
                                UrlDarkTheme = "string",
                                VerticalAlign = "string",
                            },
                            ListStreamDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetListStreamDefinitionArgs
                            {
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetListStreamDefinitionRequestArgs
                                    {
                                        Columns = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetListStreamDefinitionRequestColumnArgs
                                            {
                                                Field = "string",
                                                Width = "string",
                                            },
                                        },
                                        Query = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetListStreamDefinitionRequestQueryArgs
                                        {
                                            DataSource = "string",
                                            EventSize = "string",
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            QueryString = "string",
                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetListStreamDefinitionRequestQuerySortArgs
                                            {
                                                Column = "string",
                                                Order = "string",
                                            },
                                            Storage = "string",
                                        },
                                        ResponseFormat = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            LogStreamDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetLogStreamDefinitionArgs
                            {
                                Columns = new[]
                                {
                                    "string",
                                },
                                Indexes = new[]
                                {
                                    "string",
                                },
                                LiveSpan = "string",
                                MessageDisplay = "string",
                                Query = "string",
                                ShowDateColumn = false,
                                ShowMessageColumn = false,
                                Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetLogStreamDefinitionSortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ManageStatusDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetManageStatusDefinitionArgs
                            {
                                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.DashboardWidgetGroupDefinitionWidgetNoteDefinitionArgs
                            {
                                Content = "string",
                                BackgroundColor = "string",
                                FontSize = "string",
                                HasPadding = false,
                                ShowTick = false,
                                TextAlign = "string",
                                TickEdge = "string",
                                TickPos = "string",
                                VerticalAlign = "string",
                            },
                            PowerpackDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetPowerpackDefinitionArgs
                            {
                                PowerpackId = "string",
                                BackgroundColor = "string",
                                BannerImg = "string",
                                ShowTitle = false,
                                TemplateVariables = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetPowerpackDefinitionTemplateVariablesArgs
                                {
                                    ControlledByPowerpacks = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetPowerpackDefinitionTemplateVariablesControlledByPowerpackArgs
                                        {
                                            Name = "string",
                                            Values = new[]
                                            {
                                                "string",
                                            },
                                            Prefix = "string",
                                        },
                                    },
                                    ControlledExternallies = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetPowerpackDefinitionTemplateVariablesControlledExternallyArgs
                                        {
                                            Name = "string",
                                            Values = new[]
                                            {
                                                "string",
                                            },
                                            Prefix = "string",
                                        },
                                    },
                                },
                                Title = "string",
                            },
                            QueryTableDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionArgs
                            {
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                HasSearchBar = "string",
                                LiveSpan = "string",
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        Alias = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ApmStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                                        {
                                            Env = "string",
                                            Name = "string",
                                            PrimaryTag = "string",
                                            RowType = "string",
                                            Service = "string",
                                            Columns = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                                {
                                                    Name = "string",
                                                    Alias = "string",
                                                    CellDisplayMode = "string",
                                                    Order = "string",
                                                },
                                            },
                                            Resource = "string",
                                        },
                                        CellDisplayModes = new[]
                                        {
                                            "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        Limit = 0,
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        Order = "string",
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryTableDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            QueryValueDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionArgs
                            {
                                Autoscale = false,
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                CustomUnit = "string",
                                LiveSpan = "string",
                                Precision = 0,
                                Requests = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestArgs
                                    {
                                        Aggregator = "string",
                                        ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestApmQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestApmQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestApmQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestApmQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestApmQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        AuditQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestAuditQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ConditionalFormats = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                            {
                                                Comparator = "string",
                                                Palette = "string",
                                                Value = 0,
                                                CustomBgColor = "string",
                                                CustomFgColor = "string",
                                                HideValue = false,
                                                ImageUrl = "string",
                                                Metric = "string",
                                                Timeframe = "string",
                                            },
                                        },
                                        Formulas = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaArgs
                                            {
                                                FormulaExpression = "string",
                                                Alias = "string",
                                                CellDisplayMode = "string",
                                                ConditionalFormats = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                                    {
                                                        Comparator = "string",
                                                        Palette = "string",
                                                        Value = 0,
                                                        CustomBgColor = "string",
                                                        CustomFgColor = "string",
                                                        HideValue = false,
                                                        ImageUrl = "string",
                                                        Metric = "string",
                                                        Timeframe = "string",
                                                    },
                                                },
                                                Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                                {
                                                    Count = 0,
                                                    Order = "string",
                                                },
                                                Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                                {
                                                    Palette = "string",
                                                    PaletteIndex = 0,
                                                },
                                            },
                                        },
                                        LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestLogQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestLogQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestLogQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestLogQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestLogQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestProcessQueryArgs
                                        {
                                            Metric = "string",
                                            FilterBies = new[]
                                            {
                                                "string",
                                            },
                                            Limit = 0,
                                            SearchBy = "string",
                                        },
                                        Q = "string",
                                        Queries = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryArgs
                                            {
                                                ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    OperationName = "string",
                                                    ResourceName = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    IsUpstream = false,
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                },
                                                ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Env = "string",
                                                    Name = "string",
                                                    Service = "string",
                                                    Stat = "string",
                                                    GroupBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    OperationName = "string",
                                                    PrimaryTagName = "string",
                                                    PrimaryTagValue = "string",
                                                    ResourceName = "string",
                                                },
                                                CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                },
                                                EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                                {
                                                    Computes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Interval = 0,
                                                            Metric = "string",
                                                        },
                                                    },
                                                    DataSource = "string",
                                                    Name = "string",
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                            {
                                                                Aggregation = "string",
                                                                Metric = "string",
                                                                Order = "string",
                                                            },
                                                        },
                                                    },
                                                    Indexes = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                                    {
                                                        Query = "string",
                                                    },
                                                    Storage = "string",
                                                },
                                                MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                                {
                                                    Name = "string",
                                                    Query = "string",
                                                    Aggregator = "string",
                                                    DataSource = "string",
                                                },
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Metric = "string",
                                                    Name = "string",
                                                    Aggregator = "string",
                                                    IsNormalizedCpu = false,
                                                    Limit = 0,
                                                    Sort = "string",
                                                    TagFilters = new[]
                                                    {
                                                        "string",
                                                    },
                                                    TextFilter = "string",
                                                },
                                                SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                                {
                                                    DataSource = "string",
                                                    Measure = "string",
                                                    SloId = "string",
                                                    AdditionalQueryFilters = "string",
                                                    GroupMode = "string",
                                                    Name = "string",
                                                    SloQueryType = "string",
                                                },
                                            },
                                        },
                                        RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestRumQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestRumQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestRumQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestRumQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestRumQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                        SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestSecurityQueryArgs
                                        {
                                            Index = "string",
                                            ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestSecurityQueryComputeQueryArgs
                                            {
                                                Aggregation = "string",
                                                Facet = "string",
                                                Interval = 0,
                                            },
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestSecurityQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Order = "string",
                                                        Facet = "string",
                                                    },
                                                },
                                            },
                                            MultiComputes = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionRequestSecurityQueryMultiComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                            },
                                            SearchQuery = "string",
                                        },
                                    },
                                },
                                TextAlign = "string",
                                TimeseriesBackground = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                                {
                                    Type = "string",
                                    Yaxis = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                                    {
                                        IncludeZero = false,
                                        Label = "string",
                                        Max = "string",
                                        Min = "string",
                                        Scale = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            RunWorkflowDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetRunWorkflowDefinitionArgs
                            {
                                WorkflowId = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetRunWorkflowDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Inputs = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetRunWorkflowDefinitionInputArgs
                                    {
                                        Name = "string",
                                        Value = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            ScatterplotDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionArgs
                            {
                                ColorByGroups = new[]
                                {
                                    "string",
                                },
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                LiveSpan = "string",
                                Request = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestArgs
                                {
                                    ScatterplotTables = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableArgs
                                        {
                                            Formulas = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                                {
                                                    Dimension = "string",
                                                    FormulaExpression = "string",
                                                    Alias = "string",
                                                },
                                            },
                                            Queries = new[]
                                            {
                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                                {
                                                    ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        OperationName = "string",
                                                        ResourceName = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        IsUpstream = false,
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                    },
                                                    ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Env = "string",
                                                        Name = "string",
                                                        Service = "string",
                                                        Stat = "string",
                                                        GroupBies = new[]
                                                        {
                                                            "string",
                                                        },
                                                        OperationName = "string",
                                                        PrimaryTagName = "string",
                                                        PrimaryTagValue = "string",
                                                        ResourceName = "string",
                                                    },
                                                    CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                    },
                                                    EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                                    {
                                                        Computes = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                            {
                                                                Aggregation = "string",
                                                                Interval = 0,
                                                                Metric = "string",
                                                            },
                                                        },
                                                        DataSource = "string",
                                                        Name = "string",
                                                        GroupBies = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                            {
                                                                Facet = "string",
                                                                Limit = 0,
                                                                Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Metric = "string",
                                                                    Order = "string",
                                                                },
                                                            },
                                                        },
                                                        Indexes = new[]
                                                        {
                                                            "string",
                                                        },
                                                        Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                                        {
                                                            Query = "string",
                                                        },
                                                        Storage = "string",
                                                    },
                                                    MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                                    {
                                                        Name = "string",
                                                        Query = "string",
                                                        Aggregator = "string",
                                                        DataSource = "string",
                                                    },
                                                    ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Metric = "string",
                                                        Name = "string",
                                                        Aggregator = "string",
                                                        IsNormalizedCpu = false,
                                                        Limit = 0,
                                                        Sort = "string",
                                                        TagFilters = new[]
                                                        {
                                                            "string",
                                                        },
                                                        TextFilter = "string",
                                                    },
                                                    SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                                    {
                                                        DataSource = "string",
                                                        Measure = "string",
                                                        SloId = "string",
                                                        AdditionalQueryFilters = "string",
                                                        GroupMode = "string",
                                                        Name = "string",
                                                        SloQueryType = "string",
                                                    },
                                                },
                                            },
                                        },
                                    },
                                    Xes = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXArgs
                                        {
                                            Aggregator = "string",
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestXSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                    Ys = new[]
                                    {
                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYArgs
                                        {
                                            Aggregator = "string",
                                            ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYApmQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYApmQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYApmQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYApmQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYApmQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYLogQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYLogQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYLogQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYLogQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYLogQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                            {
                                                Metric = "string",
                                                FilterBies = new[]
                                                {
                                                    "string",
                                                },
                                                Limit = 0,
                                                SearchBy = "string",
                                            },
                                            Q = "string",
                                            RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYRumQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYRumQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYRumQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYRumQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYRumQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                            SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYSecurityQueryArgs
                                            {
                                                Index = "string",
                                                ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYSecurityQueryComputeQueryArgs
                                                {
                                                    Aggregation = "string",
                                                    Facet = "string",
                                                    Interval = 0,
                                                },
                                                GroupBies = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYSecurityQueryGroupByArgs
                                                    {
                                                        Facet = "string",
                                                        Limit = 0,
                                                        SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYSecurityQueryGroupBySortQueryArgs
                                                        {
                                                            Aggregation = "string",
                                                            Order = "string",
                                                            Facet = "string",
                                                        },
                                                    },
                                                },
                                                MultiComputes = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionRequestYSecurityQueryMultiComputeArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                },
                                                SearchQuery = "string",
                                            },
                                        },
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                                Xaxis = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionXaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                                Yaxis = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetScatterplotDefinitionYaxisArgs
                                {
                                    IncludeZero = false,
                                    Label = "string",
                                    Max = "string",
                                    Min = "string",
                                    Scale = "string",
                                },
                            },
                            ServiceLevelObjectiveDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetServiceLevelObjectiveDefinitionArgs
                            {
                                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.DashboardWidgetGroupDefinitionWidgetServicemapDefinitionArgs
                            {
                                Filters = new[]
                                {
                                    "string",
                                },
                                Service = "string",
                                CustomLinks = new[]
                                {
                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetServicemapDefinitionCustomLinkArgs
                                    {
                                        IsHidden = false,
                                        Label = "string",
                                        Link = "string",
                                        OverrideLabel = "string",
                                    },
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SloListDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSloListDefinitionArgs
                            {
                                Request = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSloListDefinitionRequestArgs
                                {
                                    Query = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSloListDefinitionRequestQueryArgs
                                    {
                                        QueryString = "string",
                                        Limit = 0,
                                        Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSloListDefinitionRequestQuerySortArgs
                                        {
                                            Column = "string",
                                            Order = "string",
                                        },
                                    },
                                    RequestType = "string",
                                },
                                Title = "string",
                                TitleAlign = "string",
                                TitleSize = "string",
                            },
                            SplitGraphDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionArgs
                            {
                                Size = "string",
                                SourceWidgetDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionArgs
                                {
                                    ChangeDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestArgs
                                            {
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestApmQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ChangeType = "string",
                                                CompareTo = "string",
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                IncreaseGood = false,
                                                LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                OrderBy = "string",
                                                OrderDir = "string",
                                                ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestProcessQueryArgs
                                                {
                                                    Metric = "string",
                                                    FilterBies = new[]
                                                    {
                                                        "string",
                                                    },
                                                    Limit = 0,
                                                    SearchBy = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            OperationName = "string",
                                                            ResourceName = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            IsUpstream = false,
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                        },
                                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            GroupBies = new[]
                                                            {
                                                                "string",
                                                            },
                                                            OperationName = "string",
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                            ResourceName = "string",
                                                        },
                                                        CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Metric = "string",
                                                            Name = "string",
                                                            Aggregator = "string",
                                                            IsNormalizedCpu = false,
                                                            Limit = 0,
                                                            Sort = "string",
                                                            TagFilters = new[]
                                                            {
                                                                "string",
                                                            },
                                                            TextFilter = "string",
                                                        },
                                                        SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                SecurityQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestSecurityQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestSecurityQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                ShowPresent = false,
                                            },
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    GeomapDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionArgs
                                    {
                                        View = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionViewArgs
                                        {
                                            Focus = "string",
                                        },
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestArgs
                                            {
                                                Formulas = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaArgs
                                                    {
                                                        FormulaExpression = "string",
                                                        Alias = "string",
                                                        CellDisplayMode = "string",
                                                        ConditionalFormats = new[]
                                                        {
                                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaConditionalFormatArgs
                                                            {
                                                                Comparator = "string",
                                                                Palette = "string",
                                                                Value = 0,
                                                                CustomBgColor = "string",
                                                                CustomFgColor = "string",
                                                                HideValue = false,
                                                                ImageUrl = "string",
                                                                Metric = "string",
                                                                Timeframe = "string",
                                                            },
                                                        },
                                                        Limit = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaLimitArgs
                                                        {
                                                            Count = 0,
                                                            Order = "string",
                                                        },
                                                        Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestFormulaStyleArgs
                                                        {
                                                            Palette = "string",
                                                            PaletteIndex = 0,
                                                        },
                                                    },
                                                },
                                                LogQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestLogQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestLogQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestLogQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestLogQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestLogQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                                Q = "string",
                                                Queries = new[]
                                                {
                                                    new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryArgs
                                                    {
                                                        ApmDependencyStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            OperationName = "string",
                                                            ResourceName = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            IsUpstream = false,
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                        },
                                                        ApmResourceStatsQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Env = "string",
                                                            Name = "string",
                                                            Service = "string",
                                                            Stat = "string",
                                                            GroupBies = new[]
                                                            {
                                                                "string",
                                                            },
                                                            OperationName = "string",
                                                            PrimaryTagName = "string",
                                                            PrimaryTagValue = "string",
                                                            ResourceName = "string",
                                                        },
                                                        CloudCostQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryCloudCostQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                        },
                                                        EventQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryArgs
                                                        {
                                                            Computes = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryComputeArgs
                                                                {
                                                                    Aggregation = "string",
                                                                    Interval = 0,
                                                                    Metric = "string",
                                                                },
                                                            },
                                                            DataSource = "string",
                                                            Name = "string",
                                                            GroupBies = new[]
                                                            {
                                                                new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                                                {
                                                                    Facet = "string",
                                                                    Limit = 0,
                                                                    Sort = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                                    {
                                                                        Aggregation = "string",
                                                                        Metric = "string",
                                                                        Order = "string",
                                                                    },
                                                                },
                                                            },
                                                            Indexes = new[]
                                                            {
                                                                "string",
                                                            },
                                                            Search = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryEventQuerySearchArgs
                                                            {
                                                                Query = "string",
                                                            },
                                                            Storage = "string",
                                                        },
                                                        MetricQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryMetricQueryArgs
                                                        {
                                                            Name = "string",
                                                            Query = "string",
                                                            Aggregator = "string",
                                                            DataSource = "string",
                                                        },
                                                        ProcessQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQueryProcessQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Metric = "string",
                                                            Name = "string",
                                                            Aggregator = "string",
                                                            IsNormalizedCpu = false,
                                                            Limit = 0,
                                                            Sort = "string",
                                                            TagFilters = new[]
                                                            {
                                                                "string",
                                                            },
                                                            TextFilter = "string",
                                                        },
                                                        SloQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestQuerySloQueryArgs
                                                        {
                                                            DataSource = "string",
                                                            Measure = "string",
                                                            SloId = "string",
                                                            AdditionalQueryFilters = "string",
                                                            GroupMode = "string",
                                                            Name = "string",
                                                            SloQueryType = "string",
                                                        },
                                                    },
                                                },
                                                RumQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestRumQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestRumQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestRumQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestRumQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet = "string",
                                                            },
                                                        },
                                                    },
                                                    MultiComputes = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionRequestRumQueryMultiComputeArgs
                                                        {
                                                            Aggregation = "string",
                                                            Facet = "string",
                                                            Interval = 0,
                                                        },
                                                    },
                                                    SearchQuery = "string",
                                                },
                                            },
                                        },
                                        Style = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionGeomapDefinitionStyleArgs
                                        {
                                            Palette = "string",
                                            PaletteFlip = false,
                                        },
                                        Title = "string",
                                        TitleAlign = "string",
                                        TitleSize = "string",
                                    },
                                    QueryTableDefinition = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionArgs
                                    {
                                        CustomLinks = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionCustomLinkArgs
                                            {
                                                IsHidden = false,
                                                Label = "string",
                                                Link = "string",
                                                OverrideLabel = "string",
                                            },
                                        },
                                        HasSearchBar = "string",
                                        LiveSpan = "string",
                                        Requests = new[]
                                        {
                                            new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestArgs
                                            {
                                                Aggregator = "string",
                                                Alias = "string",
                                                ApmQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestApmQueryArgs
                                                {
                                                    Index = "string",
                                                    ComputeQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestApmQueryComputeQueryArgs
                                                    {
                                                        Aggregation = "string",
                                                        Facet = "string",
                                                        Interval = 0,
                                                    },
                                                    GroupBies = new[]
                                                    {
                                                        new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestApmQueryGroupByArgs
                                                        {
                                                            Facet = "string",
                                                            Limit = 0,
                                                            SortQuery = new Datadog.Inputs.DashboardWidgetGroupDefinitionWidgetSplitGraphDefinitionSourceWidgetDefinitionQueryTableDefinitionRequestApmQueryGroupBySortQueryArgs
                                                            {
                                                                Aggregation = "string",
                                                                Order = "string",
                                                                Facet =