splight.DashboardAssetlistChart

import * as pulumi from "@pulumi/pulumi";
import * as splight from "@splightplatform/pulumi-splight";

const assetTest = new splight.Asset("assetTest", {
    description: "Created with Terraform",
    timezone: "America/Los_Angeles",
    geometry: JSON.stringify({
        type: "GeometryCollection",
        geometries: [],
    }),
});
const attributeTest1 = new splight.AssetAttribute("attributeTest1", {
    type: "Number",
    unit: "meters",
    asset: assetTest.id,
});
const attributeTest2 = new splight.AssetAttribute("attributeTest2", {
    type: "Number",
    unit: "seconds",
    asset: assetTest.id,
});
const dashboardTest = new splight.Dashboard("dashboardTest", {relatedAssets: []});
const dashboardTabTest = new splight.DashboardTab("dashboardTabTest", {
    order: 0,
    dashboard: dashboardTest.id,
});
const dashboardChartTest = new splight.DashboardAssetlistChart("dashboardChartTest", {
    tab: dashboardTabTest.id,
    timestampGte: "now - 7d",
    timestampLte: "now",
    description: "Chart description",
    minHeight: 1,
    minWidth: 4,
    displayTimeRange: true,
    labelsDisplay: true,
    labelsAggregation: "last",
    labelsPlacement: "bottom",
    showBeyondData: true,
    height: 10,
    width: 20,
    collection: "default",
    filterName: "some name",
    filterStatuses: ["healthy"],
    assetListType: "table",
    chartItems: [
        {
            refId: "A",
            type: "QUERY",
            color: "red",
            expressionPlain: "",
            queryFilterAsset: {
                id: assetTest.id,
                name: assetTest.name,
            },
            queryFilterAttribute: {
                id: attributeTest1.id,
                name: attributeTest1.name,
            },
            queryPlain: pulumi.jsonStringify([
                {
                    $match: {
                        asset: assetTest.id,
                        attribute: attributeTest1.id,
                    },
                },
                {
                    $addFields: {
                        timestamp: {
                            $dateTrunc: {
                                date: "$timestamp",
                                unit: "day",
                                binSize: 1,
                            },
                        },
                    },
                },
                {
                    $group: {
                        _id: "$timestamp",
                        value: {
                            $last: "$value",
                        },
                        timestamp: {
                            $last: "$timestamp",
                        },
                    },
                },
            ]),
        },
        {
            refId: "B",
            color: "blue",
            type: "QUERY",
            expressionPlain: "",
            queryFilterAsset: {
                id: assetTest.id,
                name: assetTest.name,
            },
            queryFilterAttribute: {
                id: attributeTest2.id,
                name: attributeTest2.name,
            },
            queryPlain: pulumi.jsonStringify([
                {
                    $match: {
                        asset: assetTest.id,
                        attribute: attributeTest2.id,
                    },
                },
                {
                    $addFields: {
                        timestamp: {
                            $dateTrunc: {
                                date: "$timestamp",
                                unit: "hour",
                                binSize: 1,
                            },
                        },
                    },
                },
                {
                    $group: {
                        _id: "$timestamp",
                        value: {
                            $last: "$value",
                        },
                        timestamp: {
                            $last: "$timestamp",
                        },
                    },
                },
            ]),
        },
    ],
    thresholds: [{
        color: "#00edcf",
        displayText: "T1Test",
        value: 13.1,
    }],
    valueMappings: [{
        displayText: "MODIFICADO",
        matchValue: "123.3",
        type: "exact_match",
        order: 0,
    }],
});

import pulumi
import json
import pulumi_splight as splight

asset_test = splight.Asset("assetTest",
    description="Created with Terraform",
    timezone="America/Los_Angeles",
    geometry=json.dumps({
        "type": "GeometryCollection",
        "geometries": [],
    }))
attribute_test1 = splight.AssetAttribute("attributeTest1",
    type="Number",
    unit="meters",
    asset=asset_test.id)
attribute_test2 = splight.AssetAttribute("attributeTest2",
    type="Number",
    unit="seconds",
    asset=asset_test.id)
dashboard_test = splight.Dashboard("dashboardTest", related_assets=[])
dashboard_tab_test = splight.DashboardTab("dashboardTabTest",
    order=0,
    dashboard=dashboard_test.id)
dashboard_chart_test = splight.DashboardAssetlistChart("dashboardChartTest",
    tab=dashboard_tab_test.id,
    timestamp_gte="now - 7d",
    timestamp_lte="now",
    description="Chart description",
    min_height=1,
    min_width=4,
    display_time_range=True,
    labels_display=True,
    labels_aggregation="last",
    labels_placement="bottom",
    show_beyond_data=True,
    height=10,
    width=20,
    collection="default",
    filter_name="some name",
    filter_statuses=["healthy"],
    asset_list_type="table",
    chart_items=[
        {
            "ref_id": "A",
            "type": "QUERY",
            "color": "red",
            "expression_plain": "",
            "query_filter_asset": {
                "id": asset_test.id,
                "name": asset_test.name,
            },
            "query_filter_attribute": {
                "id": attribute_test1.id,
                "name": attribute_test1.name,
            },
            "query_plain": pulumi.Output.json_dumps([
                {
                    "_match": {
                        "asset": asset_test.id,
                        "attribute": attribute_test1.id,
                    },
                },
                {
                    "$addFields": {
                        "timestamp": {
                            "$dateTrunc": {
                                "date": "$timestamp",
                                "unit": "day",
                                "binSize": 1,
                            },
                        },
                    },
                },
                {
                    "$group": {
                        "_id": "$timestamp",
                        "value": {
                            "$last": "$value",
                        },
                        "timestamp": {
                            "$last": "$timestamp",
                        },
                    },
                },
            ]),
        },
        {
            "ref_id": "B",
            "color": "blue",
            "type": "QUERY",
            "expression_plain": "",
            "query_filter_asset": {
                "id": asset_test.id,
                "name": asset_test.name,
            },
            "query_filter_attribute": {
                "id": attribute_test2.id,
                "name": attribute_test2.name,
            },
            "query_plain": pulumi.Output.json_dumps([
                {
                    "_match": {
                        "asset": asset_test.id,
                        "attribute": attribute_test2.id,
                    },
                },
                {
                    "$addFields": {
                        "timestamp": {
                            "$dateTrunc": {
                                "date": "$timestamp",
                                "unit": "hour",
                                "binSize": 1,
                            },
                        },
                    },
                },
                {
                    "$group": {
                        "_id": "$timestamp",
                        "value": {
                            "$last": "$value",
                        },
                        "timestamp": {
                            "$last": "$timestamp",
                        },
                    },
                },
            ]),
        },
    ],
    thresholds=[{
        "color": "#00edcf",
        "display_text": "T1Test",
        "value": 13.1,
    }],
    value_mappings=[{
        "display_text": "MODIFICADO",
        "match_value": "123.3",
        "type": "exact_match",
        "order": 0,
    }])

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/splightplatform/pulumi-splight/sdk/go/splight"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"type":       "GeometryCollection",
			"geometries": []interface{}{},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		assetTest, err := splight.NewAsset(ctx, "assetTest", &splight.AssetArgs{
			Description: pulumi.String("Created with Terraform"),
			Timezone:    pulumi.String("America/Los_Angeles"),
			Geometry:    pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		attributeTest1, err := splight.NewAssetAttribute(ctx, "attributeTest1", &splight.AssetAttributeArgs{
			Type:  pulumi.String("Number"),
			Unit:  pulumi.String("meters"),
			Asset: assetTest.ID(),
		})
		if err != nil {
			return err
		}
		attributeTest2, err := splight.NewAssetAttribute(ctx, "attributeTest2", &splight.AssetAttributeArgs{
			Type:  pulumi.String("Number"),
			Unit:  pulumi.String("seconds"),
			Asset: assetTest.ID(),
		})
		if err != nil {
			return err
		}
		dashboardTest, err := splight.NewDashboard(ctx, "dashboardTest", &splight.DashboardArgs{
			RelatedAssets: splight.DashboardRelatedAssetArray{},
		})
		if err != nil {
			return err
		}
		dashboardTabTest, err := splight.NewDashboardTab(ctx, "dashboardTabTest", &splight.DashboardTabArgs{
			Order:     pulumi.Int(0),
			Dashboard: dashboardTest.ID(),
		})
		if err != nil {
			return err
		}
		_, err = splight.NewDashboardAssetlistChart(ctx, "dashboardChartTest", &splight.DashboardAssetlistChartArgs{
			Tab:               dashboardTabTest.ID(),
			TimestampGte:      pulumi.String("now - 7d"),
			TimestampLte:      pulumi.String("now"),
			Description:       pulumi.String("Chart description"),
			MinHeight:         pulumi.Int(1),
			MinWidth:          pulumi.Int(4),
			DisplayTimeRange:  pulumi.Bool(true),
			LabelsDisplay:     pulumi.Bool(true),
			LabelsAggregation: pulumi.String("last"),
			LabelsPlacement:   pulumi.String("bottom"),
			ShowBeyondData:    pulumi.Bool(true),
			Height:            pulumi.Int(10),
			Width:             pulumi.Int(20),
			Collection:        pulumi.String("default"),
			FilterName:        pulumi.String("some name"),
			FilterStatuses: pulumi.StringArray{
				pulumi.String("healthy"),
			},
			AssetListType: pulumi.String("table"),
			ChartItems: splight.DashboardAssetlistChartChartItemArray{
				&splight.DashboardAssetlistChartChartItemArgs{
					RefId:           pulumi.String("A"),
					Type:            pulumi.String("QUERY"),
					Color:           pulumi.String("red"),
					ExpressionPlain: pulumi.String(""),
					QueryFilterAsset: &splight.DashboardAssetlistChartChartItemQueryFilterAssetArgs{
						Id:   assetTest.ID(),
						Name: assetTest.Name,
					},
					QueryFilterAttribute: &splight.DashboardAssetlistChartChartItemQueryFilterAttributeArgs{
						Id:   attributeTest1.ID(),
						Name: attributeTest1.Name,
					},
					QueryPlain: pulumi.All(assetTest.ID(), attributeTest1.ID()).ApplyT(func(_args []interface{}) (string, error) {
						assetTestId := _args[0].(string)
						attributeTest1Id := _args[1].(string)
						var _zero string
						tmpJSON1, err := json.Marshal([]interface{}{
							map[string]interface{}{
								"$match": map[string]interface{}{
									"asset":     assetTestId,
									"attribute": attributeTest1Id,
								},
							},
							map[string]interface{}{
								"$addFields": map[string]interface{}{
									"timestamp": map[string]interface{}{
										"$dateTrunc": map[string]interface{}{
											"date":    "$timestamp",
											"unit":    "day",
											"binSize": 1,
										},
									},
								},
							},
							map[string]interface{}{
								"$group": map[string]interface{}{
									"_id": "$timestamp",
									"value": map[string]interface{}{
										"$last": "$value",
									},
									"timestamp": map[string]interface{}{
										"$last": "$timestamp",
									},
								},
							},
						})
						if err != nil {
							return _zero, err
						}
						json1 := string(tmpJSON1)
						return json1, nil
					}).(pulumi.StringOutput),
				},
				&splight.DashboardAssetlistChartChartItemArgs{
					RefId:           pulumi.String("B"),
					Color:           pulumi.String("blue"),
					Type:            pulumi.String("QUERY"),
					ExpressionPlain: pulumi.String(""),
					QueryFilterAsset: &splight.DashboardAssetlistChartChartItemQueryFilterAssetArgs{
						Id:   assetTest.ID(),
						Name: assetTest.Name,
					},
					QueryFilterAttribute: &splight.DashboardAssetlistChartChartItemQueryFilterAttributeArgs{
						Id:   attributeTest2.ID(),
						Name: attributeTest2.Name,
					},
					QueryPlain: pulumi.All(assetTest.ID(), attributeTest2.ID()).ApplyT(func(_args []interface{}) (string, error) {
						assetTestId := _args[0].(string)
						attributeTest2Id := _args[1].(string)
						var _zero string
						tmpJSON2, err := json.Marshal([]interface{}{
							map[string]interface{}{
								"$match": map[string]interface{}{
									"asset":     assetTestId,
									"attribute": attributeTest2Id,
								},
							},
							map[string]interface{}{
								"$addFields": map[string]interface{}{
									"timestamp": map[string]interface{}{
										"$dateTrunc": map[string]interface{}{
											"date":    "$timestamp",
											"unit":    "hour",
											"binSize": 1,
										},
									},
								},
							},
							map[string]interface{}{
								"$group": map[string]interface{}{
									"_id": "$timestamp",
									"value": map[string]interface{}{
										"$last": "$value",
									},
									"timestamp": map[string]interface{}{
										"$last": "$timestamp",
									},
								},
							},
						})
						if err != nil {
							return _zero, err
						}
						json2 := string(tmpJSON2)
						return json2, nil
					}).(pulumi.StringOutput),
				},
			},
			Thresholds: splight.DashboardAssetlistChartThresholdArray{
				&splight.DashboardAssetlistChartThresholdArgs{
					Color:       pulumi.String("#00edcf"),
					DisplayText: pulumi.String("T1Test"),
					Value:       pulumi.Float64(13.1),
				},
			},
			ValueMappings: splight.DashboardAssetlistChartValueMappingArray{
				&splight.DashboardAssetlistChartValueMappingArgs{
					DisplayText: pulumi.String("MODIFICADO"),
					MatchValue:  pulumi.String("123.3"),
					Type:        pulumi.String("exact_match"),
					Order:       pulumi.Int(0),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Splight = Splight.Splight;

return await Deployment.RunAsync(() => 
{
    var assetTest = new Splight.Asset("assetTest", new()
    {
        Description = "Created with Terraform",
        Timezone = "America/Los_Angeles",
        Geometry = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["type"] = "GeometryCollection",
            ["geometries"] = new[]
            {
            },
        }),
    });

    var attributeTest1 = new Splight.AssetAttribute("attributeTest1", new()
    {
        Type = "Number",
        Unit = "meters",
        Asset = assetTest.Id,
    });

    var attributeTest2 = new Splight.AssetAttribute("attributeTest2", new()
    {
        Type = "Number",
        Unit = "seconds",
        Asset = assetTest.Id,
    });

    var dashboardTest = new Splight.Dashboard("dashboardTest", new()
    {
        RelatedAssets = new[] {},
    });

    var dashboardTabTest = new Splight.DashboardTab("dashboardTabTest", new()
    {
        Order = 0,
        Dashboard = dashboardTest.Id,
    });

    var dashboardChartTest = new Splight.DashboardAssetlistChart("dashboardChartTest", new()
    {
        Tab = dashboardTabTest.Id,
        TimestampGte = "now - 7d",
        TimestampLte = "now",
        Description = "Chart description",
        MinHeight = 1,
        MinWidth = 4,
        DisplayTimeRange = true,
        LabelsDisplay = true,
        LabelsAggregation = "last",
        LabelsPlacement = "bottom",
        ShowBeyondData = true,
        Height = 10,
        Width = 20,
        Collection = "default",
        FilterName = "some name",
        FilterStatuses = new[]
        {
            "healthy",
        },
        AssetListType = "table",
        ChartItems = new[]
        {
            new Splight.Inputs.DashboardAssetlistChartChartItemArgs
            {
                RefId = "A",
                Type = "QUERY",
                Color = "red",
                ExpressionPlain = "",
                QueryFilterAsset = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAssetArgs
                {
                    Id = assetTest.Id,
                    Name = assetTest.Name,
                },
                QueryFilterAttribute = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAttributeArgs
                {
                    Id = attributeTest1.Id,
                    Name = attributeTest1.Name,
                },
                QueryPlain = Output.JsonSerialize(Output.Create(new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["$match"] = new Dictionary<string, object?>
                        {
                            ["asset"] = assetTest.Id,
                            ["attribute"] = attributeTest1.Id,
                        },
                    },
                    new Dictionary<string, object?>
                    {
                        ["$addFields"] = new Dictionary<string, object?>
                        {
                            ["timestamp"] = new Dictionary<string, object?>
                            {
                                ["$dateTrunc"] = new Dictionary<string, object?>
                                {
                                    ["date"] = "$timestamp",
                                    ["unit"] = "day",
                                    ["binSize"] = 1,
                                },
                            },
                        },
                    },
                    new Dictionary<string, object?>
                    {
                        ["$group"] = new Dictionary<string, object?>
                        {
                            ["_id"] = "$timestamp",
                            ["value"] = new Dictionary<string, object?>
                            {
                                ["$last"] = "$value",
                            },
                            ["timestamp"] = new Dictionary<string, object?>
                            {
                                ["$last"] = "$timestamp",
                            },
                        },
                    },
                })),
            },
            new Splight.Inputs.DashboardAssetlistChartChartItemArgs
            {
                RefId = "B",
                Color = "blue",
                Type = "QUERY",
                ExpressionPlain = "",
                QueryFilterAsset = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAssetArgs
                {
                    Id = assetTest.Id,
                    Name = assetTest.Name,
                },
                QueryFilterAttribute = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAttributeArgs
                {
                    Id = attributeTest2.Id,
                    Name = attributeTest2.Name,
                },
                QueryPlain = Output.JsonSerialize(Output.Create(new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["$match"] = new Dictionary<string, object?>
                        {
                            ["asset"] = assetTest.Id,
                            ["attribute"] = attributeTest2.Id,
                        },
                    },
                    new Dictionary<string, object?>
                    {
                        ["$addFields"] = new Dictionary<string, object?>
                        {
                            ["timestamp"] = new Dictionary<string, object?>
                            {
                                ["$dateTrunc"] = new Dictionary<string, object?>
                                {
                                    ["date"] = "$timestamp",
                                    ["unit"] = "hour",
                                    ["binSize"] = 1,
                                },
                            },
                        },
                    },
                    new Dictionary<string, object?>
                    {
                        ["$group"] = new Dictionary<string, object?>
                        {
                            ["_id"] = "$timestamp",
                            ["value"] = new Dictionary<string, object?>
                            {
                                ["$last"] = "$value",
                            },
                            ["timestamp"] = new Dictionary<string, object?>
                            {
                                ["$last"] = "$timestamp",
                            },
                        },
                    },
                })),
            },
        },
        Thresholds = new[]
        {
            new Splight.Inputs.DashboardAssetlistChartThresholdArgs
            {
                Color = "#00edcf",
                DisplayText = "T1Test",
                Value = 13.1,
            },
        },
        ValueMappings = new[]
        {
            new Splight.Inputs.DashboardAssetlistChartValueMappingArgs
            {
                DisplayText = "MODIFICADO",
                MatchValue = "123.3",
                Type = "exact_match",
                Order = 0,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.splight.Asset;
import com.pulumi.splight.AssetArgs;
import com.pulumi.splight.AssetAttribute;
import com.pulumi.splight.AssetAttributeArgs;
import com.pulumi.splight.Dashboard;
import com.pulumi.splight.DashboardArgs;
import com.pulumi.splight.DashboardTab;
import com.pulumi.splight.DashboardTabArgs;
import com.pulumi.splight.DashboardAssetlistChart;
import com.pulumi.splight.DashboardAssetlistChartArgs;
import com.pulumi.splight.inputs.DashboardAssetlistChartChartItemArgs;
import com.pulumi.splight.inputs.DashboardAssetlistChartChartItemQueryFilterAssetArgs;
import com.pulumi.splight.inputs.DashboardAssetlistChartChartItemQueryFilterAttributeArgs;
import com.pulumi.splight.inputs.DashboardAssetlistChartThresholdArgs;
import com.pulumi.splight.inputs.DashboardAssetlistChartValueMappingArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var assetTest = new Asset("assetTest", AssetArgs.builder()
            .description("Created with Terraform")
            .timezone("America/Los_Angeles")
            .geometry(serializeJson(
                jsonObject(
                    jsonProperty("type", "GeometryCollection"),
                    jsonProperty("geometries", jsonArray(
                    ))
                )))
            .build());

        var attributeTest1 = new AssetAttribute("attributeTest1", AssetAttributeArgs.builder()
            .type("Number")
            .unit("meters")
            .asset(assetTest.id())
            .build());

        var attributeTest2 = new AssetAttribute("attributeTest2", AssetAttributeArgs.builder()
            .type("Number")
            .unit("seconds")
            .asset(assetTest.id())
            .build());

        var dashboardTest = new Dashboard("dashboardTest", DashboardArgs.builder()
            .relatedAssets()
            .build());

        var dashboardTabTest = new DashboardTab("dashboardTabTest", DashboardTabArgs.builder()
            .order(0)
            .dashboard(dashboardTest.id())
            .build());

        var dashboardChartTest = new DashboardAssetlistChart("dashboardChartTest", DashboardAssetlistChartArgs.builder()
            .tab(dashboardTabTest.id())
            .timestampGte("now - 7d")
            .timestampLte("now")
            .description("Chart description")
            .minHeight(1)
            .minWidth(4)
            .displayTimeRange(true)
            .labelsDisplay(true)
            .labelsAggregation("last")
            .labelsPlacement("bottom")
            .showBeyondData(true)
            .height(10)
            .width(20)
            .collection("default")
            .filterName("some name")
            .filterStatuses("healthy")
            .assetListType("table")
            .chartItems(            
                DashboardAssetlistChartChartItemArgs.builder()
                    .refId("A")
                    .type("QUERY")
                    .color("red")
                    .expressionPlain("")
                    .queryFilterAsset(DashboardAssetlistChartChartItemQueryFilterAssetArgs.builder()
                        .id(assetTest.id())
                        .name(assetTest.name())
                        .build())
                    .queryFilterAttribute(DashboardAssetlistChartChartItemQueryFilterAttributeArgs.builder()
                        .id(attributeTest1.id())
                        .name(attributeTest1.name())
                        .build())
                    .queryPlain(Output.tuple(assetTest.id(), attributeTest1.id()).applyValue(values -> {
                        var assetTestId = values.t1;
                        var attributeTest1Id = values.t2;
                        return serializeJson(
                            jsonArray(
                                jsonObject(
                                    jsonProperty("$match", jsonObject(
                                        jsonProperty("asset", assetTestId),
                                        jsonProperty("attribute", attributeTest1Id)
                                    ))
                                ), 
                                jsonObject(
                                    jsonProperty("$addFields", jsonObject(
                                        jsonProperty("timestamp", jsonObject(
                                            jsonProperty("$dateTrunc", jsonObject(
                                                jsonProperty("date", "$timestamp"),
                                                jsonProperty("unit", "day"),
                                                jsonProperty("binSize", 1)
                                            ))
                                        ))
                                    ))
                                ), 
                                jsonObject(
                                    jsonProperty("$group", jsonObject(
                                        jsonProperty("_id", "$timestamp"),
                                        jsonProperty("value", jsonObject(
                                            jsonProperty("$last", "$value")
                                        )),
                                        jsonProperty("timestamp", jsonObject(
                                            jsonProperty("$last", "$timestamp")
                                        ))
                                    ))
                                )
                            ));
                    }))
                    .build(),
                DashboardAssetlistChartChartItemArgs.builder()
                    .refId("B")
                    .color("blue")
                    .type("QUERY")
                    .expressionPlain("")
                    .queryFilterAsset(DashboardAssetlistChartChartItemQueryFilterAssetArgs.builder()
                        .id(assetTest.id())
                        .name(assetTest.name())
                        .build())
                    .queryFilterAttribute(DashboardAssetlistChartChartItemQueryFilterAttributeArgs.builder()
                        .id(attributeTest2.id())
                        .name(attributeTest2.name())
                        .build())
                    .queryPlain(Output.tuple(assetTest.id(), attributeTest2.id()).applyValue(values -> {
                        var assetTestId = values.t1;
                        var attributeTest2Id = values.t2;
                        return serializeJson(
                            jsonArray(
                                jsonObject(
                                    jsonProperty("$match", jsonObject(
                                        jsonProperty("asset", assetTestId),
                                        jsonProperty("attribute", attributeTest2Id)
                                    ))
                                ), 
                                jsonObject(
                                    jsonProperty("$addFields", jsonObject(
                                        jsonProperty("timestamp", jsonObject(
                                            jsonProperty("$dateTrunc", jsonObject(
                                                jsonProperty("date", "$timestamp"),
                                                jsonProperty("unit", "hour"),
                                                jsonProperty("binSize", 1)
                                            ))
                                        ))
                                    ))
                                ), 
                                jsonObject(
                                    jsonProperty("$group", jsonObject(
                                        jsonProperty("_id", "$timestamp"),
                                        jsonProperty("value", jsonObject(
                                            jsonProperty("$last", "$value")
                                        )),
                                        jsonProperty("timestamp", jsonObject(
                                            jsonProperty("$last", "$timestamp")
                                        ))
                                    ))
                                )
                            ));
                    }))
                    .build())
            .thresholds(DashboardAssetlistChartThresholdArgs.builder()
                .color("#00edcf")
                .displayText("T1Test")
                .value(13.1)
                .build())
            .valueMappings(DashboardAssetlistChartValueMappingArgs.builder()
                .displayText("MODIFICADO")
                .matchValue("123.3")
                .type("exact_match")
                .order(0)
                .build())
            .build());

    }
}

resources:
  assetTest:
    type: splight:Asset
    properties:
      description: Created with Terraform
      timezone: America/Los_Angeles
      geometry:
        fn::toJSON:
          type: GeometryCollection
          geometries: []
  attributeTest1:
    type: splight:AssetAttribute
    properties:
      type: Number
      unit: meters
      asset: ${assetTest.id}
  attributeTest2:
    type: splight:AssetAttribute
    properties:
      type: Number
      unit: seconds
      asset: ${assetTest.id}
  dashboardTest:
    type: splight:Dashboard
    properties:
      relatedAssets: []
  dashboardTabTest:
    type: splight:DashboardTab
    properties:
      order: 0
      dashboard: ${dashboardTest.id}
  dashboardChartTest:
    type: splight:DashboardAssetlistChart
    properties:
      tab: ${dashboardTabTest.id}
      timestampGte: now - 7d
      timestampLte: now
      description: Chart description
      minHeight: 1
      minWidth: 4
      displayTimeRange: true
      labelsDisplay: true
      labelsAggregation: last
      labelsPlacement: bottom
      showBeyondData: true
      height: 10
      width: 20
      collection: default
      filterName: some name
      filterStatuses:
        - healthy
      assetListType: table
      chartItems:
        - refId: A
          type: QUERY
          color: red
          expressionPlain:
          queryFilterAsset:
            id: ${assetTest.id}
            name: ${assetTest.name}
          queryFilterAttribute:
            id: ${attributeTest1.id}
            name: ${attributeTest1.name}
          queryPlain:
            fn::toJSON:
              - $match:
                  asset: ${assetTest.id}
                  attribute: ${attributeTest1.id}
              - $addFields:
                  timestamp:
                    $dateTrunc:
                      date: $timestamp
                      unit: day
                      binSize: 1
              - $group:
                  _id: $timestamp
                  value:
                    $last: $value
                  timestamp:
                    $last: $timestamp
        - refId: B
          color: blue
          type: QUERY
          expressionPlain:
          queryFilterAsset:
            id: ${assetTest.id}
            name: ${assetTest.name}
          queryFilterAttribute:
            id: ${attributeTest2.id}
            name: ${attributeTest2.name}
          queryPlain:
            fn::toJSON:
              - $match:
                  asset: ${assetTest.id}
                  attribute: ${attributeTest2.id}
              - $addFields:
                  timestamp:
                    $dateTrunc:
                      date: $timestamp
                      unit: hour
                      binSize: 1
              - $group:
                  _id: $timestamp
                  value:
                    $last: $value
                  timestamp:
                    $last: $timestamp
      thresholds:
        - color: '#00edcf'
          displayText: T1Test
          value: 13.1
      valueMappings:
        - displayText: MODIFICADO
          matchValue: '123.3'
          type: exact_match
          order: 0

var dashboardAssetlistChartResource = new Splight.DashboardAssetlistChart("dashboardAssetlistChartResource", new()
{
    Tab = "string",
    ChartItems = new[]
    {
        new Splight.Inputs.DashboardAssetlistChartChartItemArgs
        {
            QueryPlain = "string",
            ExpressionPlain = "string",
            Type = "string",
            Color = "string",
            QueryFilterAsset = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAssetArgs
            {
                Id = "string",
                Name = "string",
            },
            QueryFilterAttribute = new Splight.Inputs.DashboardAssetlistChartChartItemQueryFilterAttributeArgs
            {
                Id = "string",
                Name = "string",
            },
            RefId = "string",
            Label = "string",
            QueryLimit = 0,
            QueryGroupUnit = "string",
            QuerySortDirection = 0,
            QueryGroupFunction = "string",
            Hidden = false,
        },
    },
    TimestampLte = "string",
    TimestampGte = "string",
    MinWidth = 0,
    PositionY = 0,
    FilterStatuses = new[]
    {
        "string",
    },
    Height = 0,
    LabelsAggregation = "string",
    LabelsDisplay = false,
    LabelsPlacement = "string",
    MinHeight = 0,
    AssetListType = "string",
    Name = "string",
    PositionX = 0,
    FilterName = "string",
    RefreshInterval = "string",
    RelativeWindowTime = "string",
    ShowBeyondData = false,
    DisplayTimeRange = false,
    Thresholds = new[]
    {
        new Splight.Inputs.DashboardAssetlistChartThresholdArgs
        {
            Color = "string",
            DisplayText = "string",
            Value = 0,
        },
    },
    Description = "string",
    Collection = "string",
    Timezone = "string",
    ValueMappings = new[]
    {
        new Splight.Inputs.DashboardAssetlistChartValueMappingArgs
        {
            DisplayText = "string",
            MatchValue = "string",
            Order = 0,
            Type = "string",
        },
    },
    Width = 0,
});

example, err := splight.NewDashboardAssetlistChart(ctx, "dashboardAssetlistChartResource", &splight.DashboardAssetlistChartArgs{
	Tab: pulumi.String("string"),
	ChartItems: splight.DashboardAssetlistChartChartItemArray{
		&splight.DashboardAssetlistChartChartItemArgs{
			QueryPlain:      pulumi.String("string"),
			ExpressionPlain: pulumi.String("string"),
			Type:            pulumi.String("string"),
			Color:           pulumi.String("string"),
			QueryFilterAsset: &splight.DashboardAssetlistChartChartItemQueryFilterAssetArgs{
				Id:   pulumi.String("string"),
				Name: pulumi.String("string"),
			},
			QueryFilterAttribute: &splight.DashboardAssetlistChartChartItemQueryFilterAttributeArgs{
				Id:   pulumi.String("string"),
				Name: pulumi.String("string"),
			},
			RefId:              pulumi.String("string"),
			Label:              pulumi.String("string"),
			QueryLimit:         pulumi.Int(0),
			QueryGroupUnit:     pulumi.String("string"),
			QuerySortDirection: pulumi.Int(0),
			QueryGroupFunction: pulumi.String("string"),
			Hidden:             pulumi.Bool(false),
		},
	},
	TimestampLte: pulumi.String("string"),
	TimestampGte: pulumi.String("string"),
	MinWidth:     pulumi.Int(0),
	PositionY:    pulumi.Int(0),
	FilterStatuses: pulumi.StringArray{
		pulumi.String("string"),
	},
	Height:             pulumi.Int(0),
	LabelsAggregation:  pulumi.String("string"),
	LabelsDisplay:      pulumi.Bool(false),
	LabelsPlacement:    pulumi.String("string"),
	MinHeight:          pulumi.Int(0),
	AssetListType:      pulumi.String("string"),
	Name:               pulumi.String("string"),
	PositionX:          pulumi.Int(0),
	FilterName:         pulumi.String("string"),
	RefreshInterval:    pulumi.String("string"),
	RelativeWindowTime: pulumi.String("string"),
	ShowBeyondData:     pulumi.Bool(false),
	DisplayTimeRange:   pulumi.Bool(false),
	Thresholds: splight.DashboardAssetlistChartThresholdArray{
		&splight.DashboardAssetlistChartThresholdArgs{
			Color:       pulumi.String("string"),
			DisplayText: pulumi.String("string"),
			Value:       pulumi.Float64(0),
		},
	},
	Description: pulumi.String("string"),
	Collection:  pulumi.String("string"),
	Timezone:    pulumi.String("string"),
	ValueMappings: splight.DashboardAssetlistChartValueMappingArray{
		&splight.DashboardAssetlistChartValueMappingArgs{
			DisplayText: pulumi.String("string"),
			MatchValue:  pulumi.String("string"),
			Order:       pulumi.Int(0),
			Type:        pulumi.String("string"),
		},
	},
	Width: pulumi.Int(0),
})