1. Packages
  2. Datadog Provider
  3. API Docs
  4. Powerpack
Datadog v4.34.0 published on Friday, Oct 4, 2024 by Pulumi

datadog.Powerpack

Explore with Pulumi AI

datadog logo
Datadog v4.34.0 published on Friday, Oct 4, 2024 by Pulumi

    Provides a Datadog powerpack resource. This can be used to create and manage Datadog powerpacks.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as datadog from "@pulumi/datadog";
    
    // Manage Datadog Powerpacks
    const foo = new datadog.Powerpack("foo", {
        description: "Created using the Datadog provider in terraform",
        liveSpan: "4h",
        layout: {
            height: 10,
            width: 3,
            x: 1,
            y: 0,
        },
        templateVariables: [{
            defaults: ["defaults"],
            name: "datacenter",
        }],
        widgets: [{
            eventStreamDefinition: {
                query: "*",
                eventSize: "l",
                title: "Widget Title",
                titleSize: "16",
                titleAlign: "right",
            },
        }],
    });
    
    import pulumi
    import pulumi_datadog as datadog
    
    # Manage Datadog Powerpacks
    foo = datadog.Powerpack("foo",
        description="Created using the Datadog provider in terraform",
        live_span="4h",
        layout={
            "height": 10,
            "width": 3,
            "x": 1,
            "y": 0,
        },
        template_variables=[{
            "defaults": ["defaults"],
            "name": "datacenter",
        }],
        widgets=[{
            "event_stream_definition": {
                "query": "*",
                "event_size": "l",
                "title": "Widget Title",
                "title_size": "16",
                "title_align": "right",
            },
        }])
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// Manage Datadog Powerpacks
    		_, err := datadog.NewPowerpack(ctx, "foo", &datadog.PowerpackArgs{
    			Description: pulumi.String("Created using the Datadog provider in terraform"),
    			LiveSpan:    pulumi.String("4h"),
    			Layout: &datadog.PowerpackLayoutArgs{
    				Height: pulumi.Int(10),
    				Width:  pulumi.Int(3),
    				X:      pulumi.Int(1),
    				Y:      pulumi.Int(0),
    			},
    			TemplateVariables: datadog.PowerpackTemplateVariableArray{
    				&datadog.PowerpackTemplateVariableArgs{
    					Defaults: pulumi.StringArray{
    						pulumi.String("defaults"),
    					},
    					Name: pulumi.String("datacenter"),
    				},
    			},
    			Widgets: datadog.PowerpackWidgetArray{
    				&datadog.PowerpackWidgetArgs{
    					EventStreamDefinition: &datadog.PowerpackWidgetEventStreamDefinitionArgs{
    						Query:      pulumi.String("*"),
    						EventSize:  pulumi.String("l"),
    						Title:      pulumi.String("Widget Title"),
    						TitleSize:  pulumi.String("16"),
    						TitleAlign: pulumi.String("right"),
    					},
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Datadog = Pulumi.Datadog;
    
    return await Deployment.RunAsync(() => 
    {
        // Manage Datadog Powerpacks
        var foo = new Datadog.Powerpack("foo", new()
        {
            Description = "Created using the Datadog provider in terraform",
            LiveSpan = "4h",
            Layout = new Datadog.Inputs.PowerpackLayoutArgs
            {
                Height = 10,
                Width = 3,
                X = 1,
                Y = 0,
            },
            TemplateVariables = new[]
            {
                new Datadog.Inputs.PowerpackTemplateVariableArgs
                {
                    Defaults = new[]
                    {
                        "defaults",
                    },
                    Name = "datacenter",
                },
            },
            Widgets = new[]
            {
                new Datadog.Inputs.PowerpackWidgetArgs
                {
                    EventStreamDefinition = new Datadog.Inputs.PowerpackWidgetEventStreamDefinitionArgs
                    {
                        Query = "*",
                        EventSize = "l",
                        Title = "Widget Title",
                        TitleSize = "16",
                        TitleAlign = "right",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.datadog.Powerpack;
    import com.pulumi.datadog.PowerpackArgs;
    import com.pulumi.datadog.inputs.PowerpackLayoutArgs;
    import com.pulumi.datadog.inputs.PowerpackTemplateVariableArgs;
    import com.pulumi.datadog.inputs.PowerpackWidgetArgs;
    import com.pulumi.datadog.inputs.PowerpackWidgetEventStreamDefinitionArgs;
    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) {
            // Manage Datadog Powerpacks
            var foo = new Powerpack("foo", PowerpackArgs.builder()
                .description("Created using the Datadog provider in terraform")
                .liveSpan("4h")
                .layout(PowerpackLayoutArgs.builder()
                    .height(10)
                    .width(3)
                    .x(1)
                    .y(0)
                    .build())
                .templateVariables(PowerpackTemplateVariableArgs.builder()
                    .defaults("defaults")
                    .name("datacenter")
                    .build())
                .widgets(PowerpackWidgetArgs.builder()
                    .eventStreamDefinition(PowerpackWidgetEventStreamDefinitionArgs.builder()
                        .query("*")
                        .eventSize("l")
                        .title("Widget Title")
                        .titleSize(16)
                        .titleAlign("right")
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      # Manage Datadog Powerpacks
      foo:
        type: datadog:Powerpack
        properties:
          description: Created using the Datadog provider in terraform
          liveSpan: 4h
          layout:
            height: 10
            width: 3
            x: 1
            y: 0
          templateVariables:
            - defaults:
                - defaults
              name: datacenter
          widgets:
            - eventStreamDefinition:
                query: '*'
                eventSize: l
                title: Widget Title
                titleSize: 16
                titleAlign: right
    

    Create Powerpack Resource

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

    Constructor syntax

    new Powerpack(name: string, args?: PowerpackArgs, opts?: CustomResourceOptions);
    @overload
    def Powerpack(resource_name: str,
                  args: Optional[PowerpackArgs] = None,
                  opts: Optional[ResourceOptions] = None)
    
    @overload
    def Powerpack(resource_name: str,
                  opts: Optional[ResourceOptions] = None,
                  description: Optional[str] = None,
                  layout: Optional[PowerpackLayoutArgs] = None,
                  live_span: Optional[str] = None,
                  name: Optional[str] = None,
                  show_title: Optional[bool] = None,
                  tags: Optional[Sequence[str]] = None,
                  template_variables: Optional[Sequence[PowerpackTemplateVariableArgs]] = None,
                  widgets: Optional[Sequence[PowerpackWidgetArgs]] = None)
    func NewPowerpack(ctx *Context, name string, args *PowerpackArgs, opts ...ResourceOption) (*Powerpack, error)
    public Powerpack(string name, PowerpackArgs? args = null, CustomResourceOptions? opts = null)
    public Powerpack(String name, PowerpackArgs args)
    public Powerpack(String name, PowerpackArgs args, CustomResourceOptions options)
    
    type: datadog:Powerpack
    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 PowerpackArgs
    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 PowerpackArgs
    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 PowerpackArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args PowerpackArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args PowerpackArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

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

    var powerpackResource = new Datadog.Powerpack("powerpackResource", new()
    {
        Description = "string",
        Layout = new Datadog.Inputs.PowerpackLayoutArgs
        {
            Height = 0,
            Width = 0,
            X = 0,
            Y = 0,
        },
        LiveSpan = "string",
        Name = "string",
        ShowTitle = false,
        Tags = new[]
        {
            "string",
        },
        TemplateVariables = new[]
        {
            new Datadog.Inputs.PowerpackTemplateVariableArgs
            {
                Name = "string",
                Defaults = new[]
                {
                    "string",
                },
            },
        },
        Widgets = new[]
        {
            new Datadog.Inputs.PowerpackWidgetArgs
            {
                AlertGraphDefinition = new Datadog.Inputs.PowerpackWidgetAlertGraphDefinitionArgs
                {
                    AlertId = "string",
                    VizType = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                AlertValueDefinition = new Datadog.Inputs.PowerpackWidgetAlertValueDefinitionArgs
                {
                    AlertId = "string",
                    Precision = 0,
                    TextAlign = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Unit = "string",
                },
                ChangeDefinition = new Datadog.Inputs.PowerpackWidgetChangeDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetChangeDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ChangeType = "string",
                            CompareTo = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            IncreaseGood = false,
                            LogQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OrderBy = "string",
                            OrderDir = "string",
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ShowPresent = false,
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                CheckStatusDefinition = new Datadog.Inputs.PowerpackWidgetCheckStatusDefinitionArgs
                {
                    Check = "string",
                    Grouping = "string",
                    Group = "string",
                    GroupBies = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    Tags = new[]
                    {
                        "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                DistributionDefinition = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionArgs
                {
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            RumQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.PowerpackWidgetDistributionDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventStreamDefinition = new Datadog.Inputs.PowerpackWidgetEventStreamDefinitionArgs
                {
                    Query = "string",
                    EventSize = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                EventTimelineDefinition = new Datadog.Inputs.PowerpackWidgetEventTimelineDefinitionArgs
                {
                    Query = "string",
                    LiveSpan = "string",
                    TagsExecution = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                FreeTextDefinition = new Datadog.Inputs.PowerpackWidgetFreeTextDefinitionArgs
                {
                    Text = "string",
                    Color = "string",
                    FontSize = "string",
                    TextAlign = "string",
                },
                GeomapDefinition = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionArgs
                {
                    View = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionViewArgs
                    {
                        Focus = "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetGeomapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetGeomapDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    Style = new Datadog.Inputs.PowerpackWidgetGeomapDefinitionStyleArgs
                    {
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                HeatmapDefinition = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Events = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    LegendSize = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Yaxis = new Datadog.Inputs.PowerpackWidgetHeatmapDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                HostmapDefinition = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Groups = new[]
                    {
                        "string",
                    },
                    NoGroupHosts = false,
                    NoMetricHosts = false,
                    NodeType = "string",
                    Request = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestArgs
                    {
                        Fills = new[]
                        {
                            new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillArgs
                            {
                                ApmQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestFillSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                        Sizes = new[]
                        {
                            new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeArgs
                            {
                                ApmQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetHostmapDefinitionRequestSizeSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                    },
                    Scopes = new[]
                    {
                        "string",
                    },
                    Style = new Datadog.Inputs.PowerpackWidgetHostmapDefinitionStyleArgs
                    {
                        FillMax = "string",
                        FillMin = "string",
                        Palette = "string",
                        PaletteFlip = false,
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                Id = 0,
                IframeDefinition = new Datadog.Inputs.PowerpackWidgetIframeDefinitionArgs
                {
                    Url = "string",
                },
                ImageDefinition = new Datadog.Inputs.PowerpackWidgetImageDefinitionArgs
                {
                    Url = "string",
                    HasBackground = false,
                    HasBorder = false,
                    HorizontalAlign = "string",
                    Margin = "string",
                    Sizing = "string",
                    UrlDarkTheme = "string",
                    VerticalAlign = "string",
                },
                ListStreamDefinition = new Datadog.Inputs.PowerpackWidgetListStreamDefinitionArgs
                {
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetListStreamDefinitionRequestArgs
                        {
                            Columns = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetListStreamDefinitionRequestColumnArgs
                                {
                                    Field = "string",
                                    Width = "string",
                                },
                            },
                            Query = new Datadog.Inputs.PowerpackWidgetListStreamDefinitionRequestQueryArgs
                            {
                                DataSource = "string",
                                EventSize = "string",
                                Indexes = new[]
                                {
                                    "string",
                                },
                                QueryString = "string",
                                Sort = new Datadog.Inputs.PowerpackWidgetListStreamDefinitionRequestQuerySortArgs
                                {
                                    Column = "string",
                                    Order = "string",
                                },
                                Storage = "string",
                            },
                            ResponseFormat = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                LogStreamDefinition = new Datadog.Inputs.PowerpackWidgetLogStreamDefinitionArgs
                {
                    Columns = new[]
                    {
                        "string",
                    },
                    Indexes = new[]
                    {
                        "string",
                    },
                    LiveSpan = "string",
                    MessageDisplay = "string",
                    Query = "string",
                    ShowDateColumn = false,
                    ShowMessageColumn = false,
                    Sort = new Datadog.Inputs.PowerpackWidgetLogStreamDefinitionSortArgs
                    {
                        Column = "string",
                        Order = "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ManageStatusDefinition = new Datadog.Inputs.PowerpackWidgetManageStatusDefinitionArgs
                {
                    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.PowerpackWidgetNoteDefinitionArgs
                {
                    Content = "string",
                    BackgroundColor = "string",
                    FontSize = "string",
                    HasPadding = false,
                    ShowTick = false,
                    TextAlign = "string",
                    TickEdge = "string",
                    TickPos = "string",
                    VerticalAlign = "string",
                },
                QueryTableDefinition = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    HasSearchBar = "string",
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            Alias = "string",
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ApmStatsQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmStatsQueryArgs
                            {
                                Env = "string",
                                Name = "string",
                                PrimaryTag = "string",
                                RowType = "string",
                                Service = "string",
                                Columns = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestApmStatsQueryColumnArgs
                                    {
                                        Name = "string",
                                        Alias = "string",
                                        CellDisplayMode = "string",
                                        Order = "string",
                                    },
                                },
                                Resource = "string",
                            },
                            CellDisplayModes = new[]
                            {
                                "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Limit = 0,
                            LogQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Order = "string",
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            TextFormats = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestTextFormatArgs
                                {
                                    TextFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestTextFormatTextFormatArgs
                                        {
                                            Match = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestTextFormatTextFormatMatchArgs
                                            {
                                                Type = "string",
                                                Value = "string",
                                            },
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            Palette = "string",
                                            Replace = new Datadog.Inputs.PowerpackWidgetQueryTableDefinitionRequestTextFormatTextFormatReplaceArgs
                                            {
                                                Type = "string",
                                                With = "string",
                                                Substring = "string",
                                            },
                                        },
                                    },
                                },
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                QueryValueDefinition = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionArgs
                {
                    Autoscale = false,
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    CustomUnit = "string",
                    LiveSpan = "string",
                    Precision = 0,
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestArgs
                        {
                            Aggregator = "string",
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                        },
                    },
                    TextAlign = "string",
                    TimeseriesBackground = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionTimeseriesBackgroundArgs
                    {
                        Type = "string",
                        Yaxis = new Datadog.Inputs.PowerpackWidgetQueryValueDefinitionTimeseriesBackgroundYaxisArgs
                        {
                            IncludeZero = false,
                            Label = "string",
                            Max = "string",
                            Min = "string",
                            Scale = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                RunWorkflowDefinition = new Datadog.Inputs.PowerpackWidgetRunWorkflowDefinitionArgs
                {
                    WorkflowId = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetRunWorkflowDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Inputs = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetRunWorkflowDefinitionInputArgs
                        {
                            Name = "string",
                            Value = "string",
                        },
                    },
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                ScatterplotDefinition = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionArgs
                {
                    ColorByGroups = new[]
                    {
                        "string",
                    },
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Request = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestArgs
                    {
                        ScatterplotTables = new[]
                        {
                            new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableArgs
                            {
                                Formulas = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableFormulaArgs
                                    {
                                        Dimension = "string",
                                        FormulaExpression = "string",
                                        Alias = "string",
                                    },
                                },
                                Queries = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryArgs
                                    {
                                        ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryApmDependencyStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            OperationName = "string",
                                            ResourceName = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            IsUpstream = false,
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                        },
                                        ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryApmResourceStatsQueryArgs
                                        {
                                            DataSource = "string",
                                            Env = "string",
                                            Name = "string",
                                            Service = "string",
                                            Stat = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                "string",
                                            },
                                            OperationName = "string",
                                            PrimaryTagName = "string",
                                            PrimaryTagValue = "string",
                                            ResourceName = "string",
                                        },
                                        CloudCostQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryCloudCostQueryArgs
                                        {
                                            DataSource = "string",
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                        },
                                        EventQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryArgs
                                        {
                                            Computes = new[]
                                            {
                                                new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryComputeArgs
                                                {
                                                    Aggregation = "string",
                                                    Interval = 0,
                                                    Metric = "string",
                                                },
                                            },
                                            DataSource = "string",
                                            Name = "string",
                                            CrossOrgUuids = "string",
                                            GroupBies = new[]
                                            {
                                                new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupByArgs
                                                {
                                                    Facet = "string",
                                                    Limit = 0,
                                                    Sort = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQueryGroupBySortArgs
                                                    {
                                                        Aggregation = "string",
                                                        Metric = "string",
                                                        Order = "string",
                                                    },
                                                },
                                            },
                                            Indexes = new[]
                                            {
                                                "string",
                                            },
                                            Search = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryEventQuerySearchArgs
                                            {
                                                Query = "string",
                                            },
                                            Storage = "string",
                                        },
                                        MetricQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryMetricQueryArgs
                                        {
                                            Name = "string",
                                            Query = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            DataSource = "string",
                                        },
                                        ProcessQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQueryProcessQueryArgs
                                        {
                                            DataSource = "string",
                                            Metric = "string",
                                            Name = "string",
                                            Aggregator = "string",
                                            CrossOrgUuids = "string",
                                            IsNormalizedCpu = false,
                                            Limit = 0,
                                            Sort = "string",
                                            TagFilters = new[]
                                            {
                                                "string",
                                            },
                                            TextFilter = "string",
                                        },
                                        SloQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestScatterplotTableQuerySloQueryArgs
                                        {
                                            DataSource = "string",
                                            Measure = "string",
                                            SloId = "string",
                                            AdditionalQueryFilters = "string",
                                            CrossOrgUuids = "string",
                                            GroupMode = "string",
                                            Name = "string",
                                            SloQueryType = "string",
                                        },
                                    },
                                },
                            },
                        },
                        Xes = new[]
                        {
                            new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXArgs
                            {
                                Aggregator = "string",
                                ApmQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestXSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                        Ys = new[]
                        {
                            new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYArgs
                            {
                                Aggregator = "string",
                                ApmQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYApmQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYApmQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYApmQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYApmQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYApmQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                LogQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYLogQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYLogQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYLogQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYLogQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYLogQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                ProcessQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYProcessQueryArgs
                                {
                                    Metric = "string",
                                    FilterBies = new[]
                                    {
                                        "string",
                                    },
                                    Limit = 0,
                                    SearchBy = "string",
                                },
                                Q = "string",
                                RumQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYRumQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYRumQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYRumQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYRumQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYRumQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                                SecurityQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYSecurityQueryArgs
                                {
                                    Index = "string",
                                    ComputeQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYSecurityQueryComputeQueryArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                    GroupBies = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYSecurityQueryGroupByArgs
                                        {
                                            Facet = "string",
                                            Limit = 0,
                                            SortQuery = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYSecurityQueryGroupBySortQueryArgs
                                            {
                                                Aggregation = "string",
                                                Order = "string",
                                                Facet = "string",
                                            },
                                        },
                                    },
                                    MultiComputes = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionRequestYSecurityQueryMultiComputeArgs
                                        {
                                            Aggregation = "string",
                                            Facet = "string",
                                            Interval = 0,
                                        },
                                    },
                                    SearchQuery = "string",
                                },
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Xaxis = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionXaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    Yaxis = new Datadog.Inputs.PowerpackWidgetScatterplotDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ServiceLevelObjectiveDefinition = new Datadog.Inputs.PowerpackWidgetServiceLevelObjectiveDefinitionArgs
                {
                    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.PowerpackWidgetServicemapDefinitionArgs
                {
                    Filters = new[]
                    {
                        "string",
                    },
                    Service = "string",
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetServicemapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SloListDefinition = new Datadog.Inputs.PowerpackWidgetSloListDefinitionArgs
                {
                    Request = new Datadog.Inputs.PowerpackWidgetSloListDefinitionRequestArgs
                    {
                        Query = new Datadog.Inputs.PowerpackWidgetSloListDefinitionRequestQueryArgs
                        {
                            QueryString = "string",
                            Limit = 0,
                            Sort = new Datadog.Inputs.PowerpackWidgetSloListDefinitionRequestQuerySortArgs
                            {
                                Column = "string",
                                Order = "string",
                            },
                        },
                        RequestType = "string",
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                SunburstDefinition = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetSunburstDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    HideTotal = false,
                    LegendInline = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionLegendInlineArgs
                    {
                        Type = "string",
                        HidePercent = false,
                        HideValue = false,
                    },
                    LegendTable = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionLegendTableArgs
                    {
                        Type = "string",
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            NetworkQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestNetworkQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestNetworkQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestNetworkQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestNetworkQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.PowerpackWidgetSunburstDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TimeseriesDefinition = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Events = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionEventArgs
                        {
                            Q = "string",
                            TagsExecution = "string",
                        },
                    },
                    LegendColumns = new[]
                    {
                        "string",
                    },
                    LegendLayout = "string",
                    LegendSize = "string",
                    LiveSpan = "string",
                    Markers = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionMarkerArgs
                        {
                            Value = "string",
                            DisplayType = "string",
                            Label = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            DisplayType = "string",
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Metadatas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestMetadataArgs
                                {
                                    Expression = "string",
                                    AliasName = "string",
                                },
                            },
                            NetworkQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestNetworkQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestNetworkQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestNetworkQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestNetworkQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestNetworkQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            OnRightYaxis = false,
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRequestStyleArgs
                            {
                                LineType = "string",
                                LineWidth = "string",
                                Palette = "string",
                            },
                        },
                    },
                    RightYaxis = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionRightYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                    ShowLegend = false,
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                    Yaxis = new Datadog.Inputs.PowerpackWidgetTimeseriesDefinitionYaxisArgs
                    {
                        IncludeZero = false,
                        Label = "string",
                        Max = "string",
                        Min = "string",
                        Scale = "string",
                    },
                },
                ToplistDefinition = new Datadog.Inputs.PowerpackWidgetToplistDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetToplistDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    LiveSpan = "string",
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestArgs
                        {
                            ApmQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestApmQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestApmQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestApmQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestApmQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestApmQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            AuditQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestAuditQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestAuditQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestAuditQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestAuditQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestAuditQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ConditionalFormats = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestConditionalFormatArgs
                                {
                                    Comparator = "string",
                                    Palette = "string",
                                    Value = 0,
                                    CustomBgColor = "string",
                                    CustomFgColor = "string",
                                    HideValue = false,
                                    ImageUrl = "string",
                                    Metric = "string",
                                    Timeframe = "string",
                                },
                            },
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            LogQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestLogQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestLogQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestLogQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestLogQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestLogQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            ProcessQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestProcessQueryArgs
                            {
                                Metric = "string",
                                FilterBies = new[]
                                {
                                    "string",
                                },
                                Limit = 0,
                                SearchBy = "string",
                            },
                            Q = "string",
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                            RumQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestRumQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestRumQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestRumQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestRumQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestRumQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            SecurityQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestSecurityQueryArgs
                            {
                                Index = "string",
                                ComputeQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestSecurityQueryComputeQueryArgs
                                {
                                    Aggregation = "string",
                                    Facet = "string",
                                    Interval = 0,
                                },
                                GroupBies = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestSecurityQueryGroupByArgs
                                    {
                                        Facet = "string",
                                        Limit = 0,
                                        SortQuery = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestSecurityQueryGroupBySortQueryArgs
                                        {
                                            Aggregation = "string",
                                            Order = "string",
                                            Facet = "string",
                                        },
                                    },
                                },
                                MultiComputes = new[]
                                {
                                    new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestSecurityQueryMultiComputeArgs
                                    {
                                        Aggregation = "string",
                                        Facet = "string",
                                        Interval = 0,
                                    },
                                },
                                SearchQuery = "string",
                            },
                            Style = new Datadog.Inputs.PowerpackWidgetToplistDefinitionRequestStyleArgs
                            {
                                Palette = "string",
                            },
                        },
                    },
                    Styles = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetToplistDefinitionStyleArgs
                        {
                            Displays = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetToplistDefinitionStyleDisplayArgs
                                {
                                    Type = "string",
                                },
                            },
                            Palette = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TopologyMapDefinition = new Datadog.Inputs.PowerpackWidgetTopologyMapDefinitionArgs
                {
                    CustomLinks = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTopologyMapDefinitionCustomLinkArgs
                        {
                            IsHidden = false,
                            Label = "string",
                            Link = "string",
                            OverrideLabel = "string",
                        },
                    },
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTopologyMapDefinitionRequestArgs
                        {
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTopologyMapDefinitionRequestQueryArgs
                                {
                                    DataSource = "string",
                                    Filters = new[]
                                    {
                                        "string",
                                    },
                                    Service = "string",
                                },
                            },
                            RequestType = "string",
                        },
                    },
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TraceServiceDefinition = new Datadog.Inputs.PowerpackWidgetTraceServiceDefinitionArgs
                {
                    Service = "string",
                    Env = "string",
                    SpanName = "string",
                    ShowErrors = false,
                    ShowBreakdown = false,
                    ShowDistribution = false,
                    DisplayFormat = "string",
                    ShowHits = false,
                    ShowLatency = false,
                    ShowResourceList = false,
                    SizeFormat = "string",
                    LiveSpan = "string",
                    Title = "string",
                    TitleAlign = "string",
                    TitleSize = "string",
                },
                TreemapDefinition = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionArgs
                {
                    Requests = new[]
                    {
                        new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestArgs
                        {
                            Formulas = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestFormulaArgs
                                {
                                    FormulaExpression = "string",
                                    Alias = "string",
                                    CellDisplayMode = "string",
                                    ConditionalFormats = new[]
                                    {
                                        new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestFormulaConditionalFormatArgs
                                        {
                                            Comparator = "string",
                                            Palette = "string",
                                            Value = 0,
                                            CustomBgColor = "string",
                                            CustomFgColor = "string",
                                            HideValue = false,
                                            ImageUrl = "string",
                                            Metric = "string",
                                            Timeframe = "string",
                                        },
                                    },
                                    Limit = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestFormulaLimitArgs
                                    {
                                        Count = 0,
                                        Order = "string",
                                    },
                                    Style = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestFormulaStyleArgs
                                    {
                                        Palette = "string",
                                        PaletteIndex = 0,
                                    },
                                },
                            },
                            Queries = new[]
                            {
                                new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryArgs
                                {
                                    ApmDependencyStatsQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryApmDependencyStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        OperationName = "string",
                                        ResourceName = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        IsUpstream = false,
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                    },
                                    ApmResourceStatsQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryApmResourceStatsQueryArgs
                                    {
                                        DataSource = "string",
                                        Env = "string",
                                        Name = "string",
                                        Service = "string",
                                        Stat = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            "string",
                                        },
                                        OperationName = "string",
                                        PrimaryTagName = "string",
                                        PrimaryTagValue = "string",
                                        ResourceName = "string",
                                    },
                                    CloudCostQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryCloudCostQueryArgs
                                    {
                                        DataSource = "string",
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                    },
                                    EventQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryEventQueryArgs
                                    {
                                        Computes = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryEventQueryComputeArgs
                                            {
                                                Aggregation = "string",
                                                Interval = 0,
                                                Metric = "string",
                                            },
                                        },
                                        DataSource = "string",
                                        Name = "string",
                                        CrossOrgUuids = "string",
                                        GroupBies = new[]
                                        {
                                            new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryEventQueryGroupByArgs
                                            {
                                                Facet = "string",
                                                Limit = 0,
                                                Sort = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryEventQueryGroupBySortArgs
                                                {
                                                    Aggregation = "string",
                                                    Metric = "string",
                                                    Order = "string",
                                                },
                                            },
                                        },
                                        Indexes = new[]
                                        {
                                            "string",
                                        },
                                        Search = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryEventQuerySearchArgs
                                        {
                                            Query = "string",
                                        },
                                        Storage = "string",
                                    },
                                    MetricQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryMetricQueryArgs
                                    {
                                        Name = "string",
                                        Query = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        DataSource = "string",
                                    },
                                    ProcessQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQueryProcessQueryArgs
                                    {
                                        DataSource = "string",
                                        Metric = "string",
                                        Name = "string",
                                        Aggregator = "string",
                                        CrossOrgUuids = "string",
                                        IsNormalizedCpu = false,
                                        Limit = 0,
                                        Sort = "string",
                                        TagFilters = new[]
                                        {
                                            "string",
                                        },
                                        TextFilter = "string",
                                    },
                                    SloQuery = new Datadog.Inputs.PowerpackWidgetTreemapDefinitionRequestQuerySloQueryArgs
                                    {
                                        DataSource = "string",
                                        Measure = "string",
                                        SloId = "string",
                                        AdditionalQueryFilters = "string",
                                        CrossOrgUuids = "string",
                                        GroupMode = "string",
                                        Name = "string",
                                        SloQueryType = "string",
                                    },
                                },
                            },
                        },
                    },
                    Title = "string",
                },
                WidgetLayout = new Datadog.Inputs.PowerpackWidgetWidgetLayoutArgs
                {
                    Height = 0,
                    Width = 0,
                    X = 0,
                    Y = 0,
                    IsColumnBreak = false,
                },
            },
        },
    });
    
    example, err := datadog.NewPowerpack(ctx, "powerpackResource", &datadog.PowerpackArgs{
    	Description: pulumi.String("string"),
    	Layout: &datadog.PowerpackLayoutArgs{
    		Height: pulumi.Int(0),
    		Width:  pulumi.Int(0),
    		X:      pulumi.Int(0),
    		Y:      pulumi.Int(0),
    	},
    	LiveSpan:  pulumi.String("string"),
    	Name:      pulumi.String("string"),
    	ShowTitle: pulumi.Bool(false),
    	Tags: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	TemplateVariables: datadog.PowerpackTemplateVariableArray{
    		&datadog.PowerpackTemplateVariableArgs{
    			Name: pulumi.String("string"),
    			Defaults: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    		},
    	},
    	Widgets: datadog.PowerpackWidgetArray{
    		&datadog.PowerpackWidgetArgs{
    			AlertGraphDefinition: &datadog.PowerpackWidgetAlertGraphDefinitionArgs{
    				AlertId:    pulumi.String("string"),
    				VizType:    pulumi.String("string"),
    				LiveSpan:   pulumi.String("string"),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			AlertValueDefinition: &datadog.PowerpackWidgetAlertValueDefinitionArgs{
    				AlertId:    pulumi.String("string"),
    				Precision:  pulumi.Int(0),
    				TextAlign:  pulumi.String("string"),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Unit:       pulumi.String("string"),
    			},
    			ChangeDefinition: &datadog.PowerpackWidgetChangeDefinitionArgs{
    				CustomLinks: datadog.PowerpackWidgetChangeDefinitionCustomLinkArray{
    					&datadog.PowerpackWidgetChangeDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				LiveSpan: pulumi.String("string"),
    				Requests: datadog.PowerpackWidgetChangeDefinitionRequestArray{
    					&datadog.PowerpackWidgetChangeDefinitionRequestArgs{
    						ApmQuery: &datadog.PowerpackWidgetChangeDefinitionRequestApmQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetChangeDefinitionRequestApmQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetChangeDefinitionRequestApmQueryGroupByArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestApmQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetChangeDefinitionRequestApmQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetChangeDefinitionRequestApmQueryMultiComputeArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestApmQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ChangeType: pulumi.String("string"),
    						CompareTo:  pulumi.String("string"),
    						Formulas: datadog.PowerpackWidgetChangeDefinitionRequestFormulaArray{
    							&datadog.PowerpackWidgetChangeDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								ConditionalFormats: datadog.PowerpackWidgetChangeDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.PowerpackWidgetChangeDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.PowerpackWidgetChangeDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								Style: &datadog.PowerpackWidgetChangeDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						IncreaseGood: pulumi.Bool(false),
    						LogQuery: &datadog.PowerpackWidgetChangeDefinitionRequestLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetChangeDefinitionRequestLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetChangeDefinitionRequestLogQueryGroupByArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetChangeDefinitionRequestLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetChangeDefinitionRequestLogQueryMultiComputeArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						OrderBy:  pulumi.String("string"),
    						OrderDir: pulumi.String("string"),
    						ProcessQuery: &datadog.PowerpackWidgetChangeDefinitionRequestProcessQueryArgs{
    							Metric: pulumi.String("string"),
    							FilterBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Limit:    pulumi.Int(0),
    							SearchBy: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						Queries: datadog.PowerpackWidgetChangeDefinitionRequestQueryArray{
    							&datadog.PowerpackWidgetChangeDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.PowerpackWidgetChangeDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.PowerpackWidgetChangeDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						RumQuery: &datadog.PowerpackWidgetChangeDefinitionRequestRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetChangeDefinitionRequestRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetChangeDefinitionRequestRumQueryGroupByArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetChangeDefinitionRequestRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetChangeDefinitionRequestRumQueryMultiComputeArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						SecurityQuery: &datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryGroupByArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryMultiComputeArray{
    								&datadog.PowerpackWidgetChangeDefinitionRequestSecurityQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ShowPresent: pulumi.Bool(false),
    					},
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			CheckStatusDefinition: &datadog.PowerpackWidgetCheckStatusDefinitionArgs{
    				Check:    pulumi.String("string"),
    				Grouping: pulumi.String("string"),
    				Group:    pulumi.String("string"),
    				GroupBies: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				LiveSpan: pulumi.String("string"),
    				Tags: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			DistributionDefinition: &datadog.PowerpackWidgetDistributionDefinitionArgs{
    				LegendSize: pulumi.String("string"),
    				LiveSpan:   pulumi.String("string"),
    				Requests: datadog.PowerpackWidgetDistributionDefinitionRequestArray{
    					&datadog.PowerpackWidgetDistributionDefinitionRequestArgs{
    						ApmQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryGroupByArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryMultiComputeArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestApmQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ApmStatsQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestApmStatsQueryArgs{
    							Env:        pulumi.String("string"),
    							Name:       pulumi.String("string"),
    							PrimaryTag: pulumi.String("string"),
    							RowType:    pulumi.String("string"),
    							Service:    pulumi.String("string"),
    							Columns: datadog.PowerpackWidgetDistributionDefinitionRequestApmStatsQueryColumnArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestApmStatsQueryColumnArgs{
    									Name:            pulumi.String("string"),
    									Alias:           pulumi.String("string"),
    									CellDisplayMode: pulumi.String("string"),
    									Order:           pulumi.String("string"),
    								},
    							},
    							Resource: pulumi.String("string"),
    						},
    						LogQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryGroupByArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryMultiComputeArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ProcessQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestProcessQueryArgs{
    							Metric: pulumi.String("string"),
    							FilterBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Limit:    pulumi.Int(0),
    							SearchBy: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						RumQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryGroupByArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryMultiComputeArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						SecurityQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryGroupByArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArray{
    								&datadog.PowerpackWidgetDistributionDefinitionRequestSecurityQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Style: &datadog.PowerpackWidgetDistributionDefinitionRequestStyleArgs{
    							Palette: pulumi.String("string"),
    						},
    					},
    				},
    				ShowLegend: pulumi.Bool(false),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			EventStreamDefinition: &datadog.PowerpackWidgetEventStreamDefinitionArgs{
    				Query:         pulumi.String("string"),
    				EventSize:     pulumi.String("string"),
    				LiveSpan:      pulumi.String("string"),
    				TagsExecution: pulumi.String("string"),
    				Title:         pulumi.String("string"),
    				TitleAlign:    pulumi.String("string"),
    				TitleSize:     pulumi.String("string"),
    			},
    			EventTimelineDefinition: &datadog.PowerpackWidgetEventTimelineDefinitionArgs{
    				Query:         pulumi.String("string"),
    				LiveSpan:      pulumi.String("string"),
    				TagsExecution: pulumi.String("string"),
    				Title:         pulumi.String("string"),
    				TitleAlign:    pulumi.String("string"),
    				TitleSize:     pulumi.String("string"),
    			},
    			FreeTextDefinition: &datadog.PowerpackWidgetFreeTextDefinitionArgs{
    				Text:      pulumi.String("string"),
    				Color:     pulumi.String("string"),
    				FontSize:  pulumi.String("string"),
    				TextAlign: pulumi.String("string"),
    			},
    			GeomapDefinition: &datadog.PowerpackWidgetGeomapDefinitionArgs{
    				View: &datadog.PowerpackWidgetGeomapDefinitionViewArgs{
    					Focus: pulumi.String("string"),
    				},
    				CustomLinks: datadog.PowerpackWidgetGeomapDefinitionCustomLinkArray{
    					&datadog.PowerpackWidgetGeomapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				LiveSpan: pulumi.String("string"),
    				Requests: datadog.PowerpackWidgetGeomapDefinitionRequestArray{
    					&datadog.PowerpackWidgetGeomapDefinitionRequestArgs{
    						Formulas: datadog.PowerpackWidgetGeomapDefinitionRequestFormulaArray{
    							&datadog.PowerpackWidgetGeomapDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								ConditionalFormats: datadog.PowerpackWidgetGeomapDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.PowerpackWidgetGeomapDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.PowerpackWidgetGeomapDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								Style: &datadog.PowerpackWidgetGeomapDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						LogQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryGroupByArray{
    								&datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryMultiComputeArray{
    								&datadog.PowerpackWidgetGeomapDefinitionRequestLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						Queries: datadog.PowerpackWidgetGeomapDefinitionRequestQueryArray{
    							&datadog.PowerpackWidgetGeomapDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						RumQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryGroupByArray{
    								&datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryMultiComputeArray{
    								&datadog.PowerpackWidgetGeomapDefinitionRequestRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    					},
    				},
    				Style: &datadog.PowerpackWidgetGeomapDefinitionStyleArgs{
    					Palette:     pulumi.String("string"),
    					PaletteFlip: pulumi.Bool(false),
    				},
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    			},
    			HeatmapDefinition: &datadog.PowerpackWidgetHeatmapDefinitionArgs{
    				CustomLinks: datadog.PowerpackWidgetHeatmapDefinitionCustomLinkArray{
    					&datadog.PowerpackWidgetHeatmapDefinitionCustomLinkArgs{
    						IsHidden:      pulumi.Bool(false),
    						Label:         pulumi.String("string"),
    						Link:          pulumi.String("string"),
    						OverrideLabel: pulumi.String("string"),
    					},
    				},
    				Events: datadog.PowerpackWidgetHeatmapDefinitionEventArray{
    					&datadog.PowerpackWidgetHeatmapDefinitionEventArgs{
    						Q:             pulumi.String("string"),
    						TagsExecution: pulumi.String("string"),
    					},
    				},
    				LegendSize: pulumi.String("string"),
    				LiveSpan:   pulumi.String("string"),
    				Requests: datadog.PowerpackWidgetHeatmapDefinitionRequestArray{
    					&datadog.PowerpackWidgetHeatmapDefinitionRequestArgs{
    						ApmQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryGroupByArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryMultiComputeArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestApmQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Formulas: datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaArray{
    							&datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaArgs{
    								FormulaExpression: pulumi.String("string"),
    								Alias:             pulumi.String("string"),
    								CellDisplayMode:   pulumi.String("string"),
    								ConditionalFormats: datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaConditionalFormatArray{
    									&datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaConditionalFormatArgs{
    										Comparator:    pulumi.String("string"),
    										Palette:       pulumi.String("string"),
    										Value:         pulumi.Float64(0),
    										CustomBgColor: pulumi.String("string"),
    										CustomFgColor: pulumi.String("string"),
    										HideValue:     pulumi.Bool(false),
    										ImageUrl:      pulumi.String("string"),
    										Metric:        pulumi.String("string"),
    										Timeframe:     pulumi.String("string"),
    									},
    								},
    								Limit: &datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaLimitArgs{
    									Count: pulumi.Int(0),
    									Order: pulumi.String("string"),
    								},
    								Style: &datadog.PowerpackWidgetHeatmapDefinitionRequestFormulaStyleArgs{
    									Palette:      pulumi.String("string"),
    									PaletteIndex: pulumi.Int(0),
    								},
    							},
    						},
    						LogQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryGroupByArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryMultiComputeArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestLogQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						ProcessQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestProcessQueryArgs{
    							Metric: pulumi.String("string"),
    							FilterBies: pulumi.StringArray{
    								pulumi.String("string"),
    							},
    							Limit:    pulumi.Int(0),
    							SearchBy: pulumi.String("string"),
    						},
    						Q: pulumi.String("string"),
    						Queries: datadog.PowerpackWidgetHeatmapDefinitionRequestQueryArray{
    							&datadog.PowerpackWidgetHeatmapDefinitionRequestQueryArgs{
    								ApmDependencyStatsQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryApmDependencyStatsQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Env:             pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									OperationName:   pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    									Service:         pulumi.String("string"),
    									Stat:            pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsUpstream:      pulumi.Bool(false),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    								},
    								ApmResourceStatsQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryApmResourceStatsQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Env:           pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Service:       pulumi.String("string"),
    									Stat:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									OperationName:   pulumi.String("string"),
    									PrimaryTagName:  pulumi.String("string"),
    									PrimaryTagValue: pulumi.String("string"),
    									ResourceName:    pulumi.String("string"),
    								},
    								CloudCostQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryCloudCostQueryArgs{
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    								},
    								EventQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryArgs{
    									Computes: datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryComputeArray{
    										&datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryComputeArgs{
    											Aggregation: pulumi.String("string"),
    											Interval:    pulumi.Int(0),
    											Metric:      pulumi.String("string"),
    										},
    									},
    									DataSource:    pulumi.String("string"),
    									Name:          pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									GroupBies: datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArray{
    										&datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryGroupByArgs{
    											Facet: pulumi.String("string"),
    											Limit: pulumi.Int(0),
    											Sort: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQueryGroupBySortArgs{
    												Aggregation: pulumi.String("string"),
    												Metric:      pulumi.String("string"),
    												Order:       pulumi.String("string"),
    											},
    										},
    									},
    									Indexes: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									Search: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryEventQuerySearchArgs{
    										Query: pulumi.String("string"),
    									},
    									Storage: pulumi.String("string"),
    								},
    								MetricQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryMetricQueryArgs{
    									Name:          pulumi.String("string"),
    									Query:         pulumi.String("string"),
    									Aggregator:    pulumi.String("string"),
    									CrossOrgUuids: pulumi.String("string"),
    									DataSource:    pulumi.String("string"),
    								},
    								ProcessQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQueryProcessQueryArgs{
    									DataSource:      pulumi.String("string"),
    									Metric:          pulumi.String("string"),
    									Name:            pulumi.String("string"),
    									Aggregator:      pulumi.String("string"),
    									CrossOrgUuids:   pulumi.String("string"),
    									IsNormalizedCpu: pulumi.Bool(false),
    									Limit:           pulumi.Int(0),
    									Sort:            pulumi.String("string"),
    									TagFilters: pulumi.StringArray{
    										pulumi.String("string"),
    									},
    									TextFilter: pulumi.String("string"),
    								},
    								SloQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestQuerySloQueryArgs{
    									DataSource:             pulumi.String("string"),
    									Measure:                pulumi.String("string"),
    									SloId:                  pulumi.String("string"),
    									AdditionalQueryFilters: pulumi.String("string"),
    									CrossOrgUuids:          pulumi.String("string"),
    									GroupMode:              pulumi.String("string"),
    									Name:                   pulumi.String("string"),
    									SloQueryType:           pulumi.String("string"),
    								},
    							},
    						},
    						RumQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryGroupByArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryMultiComputeArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestRumQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						SecurityQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryArgs{
    							Index: pulumi.String("string"),
    							ComputeQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryComputeQueryArgs{
    								Aggregation: pulumi.String("string"),
    								Facet:       pulumi.String("string"),
    								Interval:    pulumi.Int(0),
    							},
    							GroupBies: datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryGroupByArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryGroupByArgs{
    									Facet: pulumi.String("string"),
    									Limit: pulumi.Int(0),
    									SortQuery: &datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryGroupBySortQueryArgs{
    										Aggregation: pulumi.String("string"),
    										Order:       pulumi.String("string"),
    										Facet:       pulumi.String("string"),
    									},
    								},
    							},
    							MultiComputes: datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryMultiComputeArray{
    								&datadog.PowerpackWidgetHeatmapDefinitionRequestSecurityQueryMultiComputeArgs{
    									Aggregation: pulumi.String("string"),
    									Facet:       pulumi.String("string"),
    									Interval:    pulumi.Int(0),
    								},
    							},
    							SearchQuery: pulumi.String("string"),
    						},
    						Style: &datadog.PowerpackWidgetHeatmapDefinitionRequestStyleArgs{
    							Palette: pulumi.String("string"),
    						},
    					},
    				},
    				ShowLegend: pulumi.Bool(false),
    				Title:      pulumi.String("string"),
    				TitleAlign: pulumi.String("string"),
    				TitleSize:  pulumi.String("string"),
    				Yaxis: &datadog.PowerpackWidgetHeatmapDefinitionYaxisArgs{
    					IncludeZero: pulumi.Bool(false),
    					Label:       pulumi.String("string"),
    					Max:         pulumi.String("string"),
    					Min:         pulumi.String("string"),
    					Scale:       pulumi.String("string"),
    				},
    			},
    			HostmapDefinition: &datadog.PowerpackWidgetHostmapDefinitionArgs{
    				CustomLinks: datadog.PowerpackWidgetHostmapDefinitionCustomLinkArray{
    					&datadog.PowerpackWidgetHostmapDefinitionCustomLinkArgs{
    						IsHidden:      <