elasticstack.KibanaDashboard

import * as pulumi from "@pulumi/pulumi";
import * as elasticstack from "@pulumi/elasticstack";

const myDashboard = new elasticstack.KibanaDashboard("my_dashboard", {
    title: "My Dashboard",
    description: "A dashboard showing key metrics",
    timeRange: {
        from: "now-15m",
        to: "now",
    },
    refreshInterval: {
        pause: false,
        value: 60000,
    },
    query: {
        language: "kql",
        text: "status:success",
    },
    tags: [
        "production",
        "monitoring",
    ],
});
// Example with JSON query (mutually exclusive with query.text)
const myDashboardJson = new elasticstack.KibanaDashboard("my_dashboard_json", {
    title: "My Dashboard with JSON Query",
    description: "A dashboard with a structured query",
    timeRange: {
        from: "now-15m",
        to: "now",
    },
    refreshInterval: {
        pause: false,
        value: 60000,
    },
    query: {
        language: "kql",
        json: JSON.stringify({
            bool: {
                must: [{
                    match: {
                        status: "success",
                    },
                }],
            },
        }),
    },
    tags: [
        "production",
        "monitoring",
    ],
});
// Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
const visTypedByValue = new elasticstack.KibanaDashboard("vis_typed_by_value", {
    title: "Dashboard with vis (typed by-value)",
    description: "Example: metric via vis_config.by_value.metric_chart_config",
    timeRange: {
        from: "now-15m",
        to: "now",
    },
    refreshInterval: {
        pause: true,
        value: 0,
    },
    query: {
        language: "kql",
        text: "",
    },
    panels: [{
        type: "vis",
        grid: {
            x: 0,
            y: 0,
            w: 24,
            h: 15,
        },
        visConfig: {
            byValue: {
                metricChartConfig: {
                    dataSourceJson: JSON.stringify({
                        type: "data_view_spec",
                        index_pattern: "metrics-*",
                        time_field: "@timestamp",
                    }),
                    query: {
                        expression: "",
                    },
                    metrics: [{
                        configJson: JSON.stringify({
                            type: "primary",
                            operation: "count",
                            format: {
                                type: "number",
                            },
                        }),
                    }],
                },
            },
        },
    }],
});
// Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
// (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
// Kibana API (link behavior via `open_links_in_new_tab`).
const markdownByValue = new elasticstack.KibanaDashboard("markdown_by_value", {
    title: "Dashboard with markdown (by-value)",
    description: "Example: markdown_config.by_value with settings",
    timeRange: {
        from: "now-15m",
        to: "now",
    },
    refreshInterval: {
        pause: true,
        value: 0,
    },
    query: {
        language: "kql",
        text: "",
    },
    panels: [{
        type: "markdown",
        grid: {
            x: 0,
            y: 0,
            w: 24,
            h: 10,
        },
        markdownConfig: {
            byValue: {
                content: `# Runbook

Links respect **open_links_in_new_tab**.`,
                title: "On-call notes",
                settings: {
                    openLinksInNewTab: true,
                },
            },
        },
    }],
});
// By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
// or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
// markdown library items today.
const markdownByReference = new elasticstack.KibanaDashboard("markdown_by_reference", {
    title: "Dashboard with markdown (by-reference)",
    description: "Example: markdown_config.by_reference with a placeholder ref_id",
    timeRange: {
        from: "now-15m",
        to: "now",
    },
    refreshInterval: {
        pause: true,
        value: 0,
    },
    query: {
        language: "kql",
        text: "",
    },
    panels: [{
        type: "markdown",
        grid: {
            x: 0,
            y: 0,
            w: 24,
            h: 10,
        },
        markdownConfig: {
            byReference: {
                refId: "REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID",
                title: "Title overlay for library markdown",
            },
        },
    }],
});

import pulumi
import json
import pulumi_elasticstack as elasticstack

my_dashboard = elasticstack.KibanaDashboard("my_dashboard",
    title="My Dashboard",
    description="A dashboard showing key metrics",
    time_range={
        "from_": "now-15m",
        "to": "now",
    },
    refresh_interval={
        "pause": False,
        "value": 60000,
    },
    query={
        "language": "kql",
        "text": "status:success",
    },
    tags=[
        "production",
        "monitoring",
    ])
# Example with JSON query (mutually exclusive with query.text)
my_dashboard_json = elasticstack.KibanaDashboard("my_dashboard_json",
    title="My Dashboard with JSON Query",
    description="A dashboard with a structured query",
    time_range={
        "from_": "now-15m",
        "to": "now",
    },
    refresh_interval={
        "pause": False,
        "value": 60000,
    },
    query={
        "language": "kql",
        "json": json.dumps({
            "bool": {
                "must": [{
                    "match": {
                        "status": "success",
                    },
                }],
            },
        }),
    },
    tags=[
        "production",
        "monitoring",
    ])
# Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
vis_typed_by_value = elasticstack.KibanaDashboard("vis_typed_by_value",
    title="Dashboard with vis (typed by-value)",
    description="Example: metric via vis_config.by_value.metric_chart_config",
    time_range={
        "from_": "now-15m",
        "to": "now",
    },
    refresh_interval={
        "pause": True,
        "value": 0,
    },
    query={
        "language": "kql",
        "text": "",
    },
    panels=[{
        "type": "vis",
        "grid": {
            "x": 0,
            "y": 0,
            "w": 24,
            "h": 15,
        },
        "vis_config": {
            "by_value": {
                "metric_chart_config": {
                    "data_source_json": json.dumps({
                        "type": "data_view_spec",
                        "index_pattern": "metrics-*",
                        "time_field": "@timestamp",
                    }),
                    "query": {
                        "expression": "",
                    },
                    "metrics": [{
                        "config_json": json.dumps({
                            "type": "primary",
                            "operation": "count",
                            "format": {
                                "type": "number",
                            },
                        }),
                    }],
                },
            },
        },
    }])
# Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
# (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
# Kibana API (link behavior via `open_links_in_new_tab`).
markdown_by_value = elasticstack.KibanaDashboard("markdown_by_value",
    title="Dashboard with markdown (by-value)",
    description="Example: markdown_config.by_value with settings",
    time_range={
        "from_": "now-15m",
        "to": "now",
    },
    refresh_interval={
        "pause": True,
        "value": 0,
    },
    query={
        "language": "kql",
        "text": "",
    },
    panels=[{
        "type": "markdown",
        "grid": {
            "x": 0,
            "y": 0,
            "w": 24,
            "h": 10,
        },
        "markdown_config": {
            "by_value": {
                "content": """# Runbook

Links respect **open_links_in_new_tab**.""",
                "title": "On-call notes",
                "settings": {
                    "open_links_in_new_tab": True,
                },
            },
        },
    }])
# By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
# or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
# markdown library items today.
markdown_by_reference = elasticstack.KibanaDashboard("markdown_by_reference",
    title="Dashboard with markdown (by-reference)",
    description="Example: markdown_config.by_reference with a placeholder ref_id",
    time_range={
        "from_": "now-15m",
        "to": "now",
    },
    refresh_interval={
        "pause": True,
        "value": 0,
    },
    query={
        "language": "kql",
        "text": "",
    },
    panels=[{
        "type": "markdown",
        "grid": {
            "x": 0,
            "y": 0,
            "w": 24,
            "h": 10,
        },
        "markdown_config": {
            "by_reference": {
                "ref_id": "REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID",
                "title": "Title overlay for library markdown",
            },
        },
    }])

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := elasticstack.NewKibanaDashboard(ctx, "my_dashboard", &elasticstack.KibanaDashboardArgs{
			Title:       pulumi.String("My Dashboard"),
			Description: pulumi.String("A dashboard showing key metrics"),
			TimeRange: &elasticstack.KibanaDashboardTimeRangeArgs{
				From: pulumi.String("now-15m"),
				To:   pulumi.String("now"),
			},
			RefreshInterval: &elasticstack.KibanaDashboardRefreshIntervalArgs{
				Pause: pulumi.Bool(false),
				Value: pulumi.Float64(60000),
			},
			Query: &elasticstack.KibanaDashboardQueryArgs{
				Language: pulumi.String("kql"),
				Text:     pulumi.String("status:success"),
			},
			Tags: pulumi.StringArray{
				pulumi.String("production"),
				pulumi.String("monitoring"),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"bool": map[string]interface{}{
				"must": []map[string]interface{}{
					map[string]interface{}{
						"match": map[string]interface{}{
							"status": "success",
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// Example with JSON query (mutually exclusive with query.text)
		_, err = elasticstack.NewKibanaDashboard(ctx, "my_dashboard_json", &elasticstack.KibanaDashboardArgs{
			Title:       pulumi.String("My Dashboard with JSON Query"),
			Description: pulumi.String("A dashboard with a structured query"),
			TimeRange: &elasticstack.KibanaDashboardTimeRangeArgs{
				From: pulumi.String("now-15m"),
				To:   pulumi.String("now"),
			},
			RefreshInterval: &elasticstack.KibanaDashboardRefreshIntervalArgs{
				Pause: pulumi.Bool(false),
				Value: pulumi.Float64(60000),
			},
			Query: &elasticstack.KibanaDashboardQueryArgs{
				Language: pulumi.String("kql"),
				Json:     pulumi.String(json0),
			},
			Tags: pulumi.StringArray{
				pulumi.String("production"),
				pulumi.String("monitoring"),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"type":          "data_view_spec",
			"index_pattern": "metrics-*",
			"time_field":    "@timestamp",
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"type":      "primary",
			"operation": "count",
			"format": map[string]interface{}{
				"type": "number",
			},
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		// Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
		_, err = elasticstack.NewKibanaDashboard(ctx, "vis_typed_by_value", &elasticstack.KibanaDashboardArgs{
			Title:       pulumi.String("Dashboard with vis (typed by-value)"),
			Description: pulumi.String("Example: metric via vis_config.by_value.metric_chart_config"),
			TimeRange: &elasticstack.KibanaDashboardTimeRangeArgs{
				From: pulumi.String("now-15m"),
				To:   pulumi.String("now"),
			},
			RefreshInterval: &elasticstack.KibanaDashboardRefreshIntervalArgs{
				Pause: pulumi.Bool(true),
				Value: pulumi.Float64(0),
			},
			Query: &elasticstack.KibanaDashboardQueryArgs{
				Language: pulumi.String("kql"),
				Text:     pulumi.String(""),
			},
			Panels: elasticstack.KibanaDashboardPanelArray{
				&elasticstack.KibanaDashboardPanelArgs{
					Type: pulumi.String("vis"),
					Grid: &elasticstack.KibanaDashboardPanelGridArgs{
						X: pulumi.Float64(0),
						Y: pulumi.Float64(0),
						W: pulumi.Float64(24),
						H: pulumi.Float64(15),
					},
					VisConfig: &elasticstack.KibanaDashboardPanelVisConfigArgs{
						ByValue: &elasticstack.KibanaDashboardPanelVisConfigByValueArgs{
							MetricChartConfig: &elasticstack.KibanaDashboardPanelVisConfigByValueMetricChartConfigArgs{
								DataSourceJson: pulumi.String(json1),
								Query: &elasticstack.KibanaDashboardPanelVisConfigByValueMetricChartConfigQueryArgs{
									Expression: pulumi.String(""),
								},
								Metrics: elasticstack.KibanaDashboardPanelVisConfigByValueMetricChartConfigMetricArray{
									&elasticstack.KibanaDashboardPanelVisConfigByValueMetricChartConfigMetricArgs{
										ConfigJson: pulumi.String(json2),
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
		// (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
		// Kibana API (link behavior via `open_links_in_new_tab`).
		_, err = elasticstack.NewKibanaDashboard(ctx, "markdown_by_value", &elasticstack.KibanaDashboardArgs{
			Title:       pulumi.String("Dashboard with markdown (by-value)"),
			Description: pulumi.String("Example: markdown_config.by_value with settings"),
			TimeRange: &elasticstack.KibanaDashboardTimeRangeArgs{
				From: pulumi.String("now-15m"),
				To:   pulumi.String("now"),
			},
			RefreshInterval: &elasticstack.KibanaDashboardRefreshIntervalArgs{
				Pause: pulumi.Bool(true),
				Value: pulumi.Float64(0),
			},
			Query: &elasticstack.KibanaDashboardQueryArgs{
				Language: pulumi.String("kql"),
				Text:     pulumi.String(""),
			},
			Panels: elasticstack.KibanaDashboardPanelArray{
				&elasticstack.KibanaDashboardPanelArgs{
					Type: pulumi.String("markdown"),
					Grid: &elasticstack.KibanaDashboardPanelGridArgs{
						X: pulumi.Float64(0),
						Y: pulumi.Float64(0),
						W: pulumi.Float64(24),
						H: pulumi.Float64(10),
					},
					MarkdownConfig: &elasticstack.KibanaDashboardPanelMarkdownConfigArgs{
						ByValue: &elasticstack.KibanaDashboardPanelMarkdownConfigByValueArgs{
							Content: pulumi.String("# Runbook\n\nLinks respect **open_links_in_new_tab**."),
							Title:   pulumi.String("On-call notes"),
							Settings: &elasticstack.KibanaDashboardPanelMarkdownConfigByValueSettingsArgs{
								OpenLinksInNewTab: pulumi.Bool(true),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		// By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
		// or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
		// markdown library items today.
		_, err = elasticstack.NewKibanaDashboard(ctx, "markdown_by_reference", &elasticstack.KibanaDashboardArgs{
			Title:       pulumi.String("Dashboard with markdown (by-reference)"),
			Description: pulumi.String("Example: markdown_config.by_reference with a placeholder ref_id"),
			TimeRange: &elasticstack.KibanaDashboardTimeRangeArgs{
				From: pulumi.String("now-15m"),
				To:   pulumi.String("now"),
			},
			RefreshInterval: &elasticstack.KibanaDashboardRefreshIntervalArgs{
				Pause: pulumi.Bool(true),
				Value: pulumi.Float64(0),
			},
			Query: &elasticstack.KibanaDashboardQueryArgs{
				Language: pulumi.String("kql"),
				Text:     pulumi.String(""),
			},
			Panels: elasticstack.KibanaDashboardPanelArray{
				&elasticstack.KibanaDashboardPanelArgs{
					Type: pulumi.String("markdown"),
					Grid: &elasticstack.KibanaDashboardPanelGridArgs{
						X: pulumi.Float64(0),
						Y: pulumi.Float64(0),
						W: pulumi.Float64(24),
						H: pulumi.Float64(10),
					},
					MarkdownConfig: &elasticstack.KibanaDashboardPanelMarkdownConfigArgs{
						ByReference: &elasticstack.KibanaDashboardPanelMarkdownConfigByReferenceArgs{
							RefId: pulumi.String("REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID"),
							Title: pulumi.String("Title overlay for library markdown"),
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var myDashboard = new Elasticstack.KibanaDashboard("my_dashboard", new()
    {
        Title = "My Dashboard",
        Description = "A dashboard showing key metrics",
        TimeRange = new Elasticstack.Inputs.KibanaDashboardTimeRangeArgs
        {
            From = "now-15m",
            To = "now",
        },
        RefreshInterval = new Elasticstack.Inputs.KibanaDashboardRefreshIntervalArgs
        {
            Pause = false,
            Value = 60000,
        },
        Query = new Elasticstack.Inputs.KibanaDashboardQueryArgs
        {
            Language = "kql",
            Text = "status:success",
        },
        Tags = new[]
        {
            "production",
            "monitoring",
        },
    });

    // Example with JSON query (mutually exclusive with query.text)
    var myDashboardJson = new Elasticstack.KibanaDashboard("my_dashboard_json", new()
    {
        Title = "My Dashboard with JSON Query",
        Description = "A dashboard with a structured query",
        TimeRange = new Elasticstack.Inputs.KibanaDashboardTimeRangeArgs
        {
            From = "now-15m",
            To = "now",
        },
        RefreshInterval = new Elasticstack.Inputs.KibanaDashboardRefreshIntervalArgs
        {
            Pause = false,
            Value = 60000,
        },
        Query = new Elasticstack.Inputs.KibanaDashboardQueryArgs
        {
            Language = "kql",
            Json = JsonSerializer.Serialize(new Dictionary<string, object?>
            {
                ["bool"] = new Dictionary<string, object?>
                {
                    ["must"] = new[]
                    {
                        new Dictionary<string, object?>
                        {
                            ["match"] = new Dictionary<string, object?>
                            {
                                ["status"] = "success",
                            },
                        },
                    },
                },
            }),
        },
        Tags = new[]
        {
            "production",
            "monitoring",
        },
    });

    // Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
    var visTypedByValue = new Elasticstack.KibanaDashboard("vis_typed_by_value", new()
    {
        Title = "Dashboard with vis (typed by-value)",
        Description = "Example: metric via vis_config.by_value.metric_chart_config",
        TimeRange = new Elasticstack.Inputs.KibanaDashboardTimeRangeArgs
        {
            From = "now-15m",
            To = "now",
        },
        RefreshInterval = new Elasticstack.Inputs.KibanaDashboardRefreshIntervalArgs
        {
            Pause = true,
            Value = 0,
        },
        Query = new Elasticstack.Inputs.KibanaDashboardQueryArgs
        {
            Language = "kql",
            Text = "",
        },
        Panels = new[]
        {
            new Elasticstack.Inputs.KibanaDashboardPanelArgs
            {
                Type = "vis",
                Grid = new Elasticstack.Inputs.KibanaDashboardPanelGridArgs
                {
                    X = 0,
                    Y = 0,
                    W = 24,
                    H = 15,
                },
                VisConfig = new Elasticstack.Inputs.KibanaDashboardPanelVisConfigArgs
                {
                    ByValue = new Elasticstack.Inputs.KibanaDashboardPanelVisConfigByValueArgs
                    {
                        MetricChartConfig = new Elasticstack.Inputs.KibanaDashboardPanelVisConfigByValueMetricChartConfigArgs
                        {
                            DataSourceJson = JsonSerializer.Serialize(new Dictionary<string, object?>
                            {
                                ["type"] = "data_view_spec",
                                ["index_pattern"] = "metrics-*",
                                ["time_field"] = "@timestamp",
                            }),
                            Query = new Elasticstack.Inputs.KibanaDashboardPanelVisConfigByValueMetricChartConfigQueryArgs
                            {
                                Expression = "",
                            },
                            Metrics = new[]
                            {
                                new Elasticstack.Inputs.KibanaDashboardPanelVisConfigByValueMetricChartConfigMetricArgs
                                {
                                    ConfigJson = JsonSerializer.Serialize(new Dictionary<string, object?>
                                    {
                                        ["type"] = "primary",
                                        ["operation"] = "count",
                                        ["format"] = new Dictionary<string, object?>
                                        {
                                            ["type"] = "number",
                                        },
                                    }),
                                },
                            },
                        },
                    },
                },
            },
        },
    });

    // Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
    // (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
    // Kibana API (link behavior via `open_links_in_new_tab`).
    var markdownByValue = new Elasticstack.KibanaDashboard("markdown_by_value", new()
    {
        Title = "Dashboard with markdown (by-value)",
        Description = "Example: markdown_config.by_value with settings",
        TimeRange = new Elasticstack.Inputs.KibanaDashboardTimeRangeArgs
        {
            From = "now-15m",
            To = "now",
        },
        RefreshInterval = new Elasticstack.Inputs.KibanaDashboardRefreshIntervalArgs
        {
            Pause = true,
            Value = 0,
        },
        Query = new Elasticstack.Inputs.KibanaDashboardQueryArgs
        {
            Language = "kql",
            Text = "",
        },
        Panels = new[]
        {
            new Elasticstack.Inputs.KibanaDashboardPanelArgs
            {
                Type = "markdown",
                Grid = new Elasticstack.Inputs.KibanaDashboardPanelGridArgs
                {
                    X = 0,
                    Y = 0,
                    W = 24,
                    H = 10,
                },
                MarkdownConfig = new Elasticstack.Inputs.KibanaDashboardPanelMarkdownConfigArgs
                {
                    ByValue = new Elasticstack.Inputs.KibanaDashboardPanelMarkdownConfigByValueArgs
                    {
                        Content = @"# Runbook

Links respect **open_links_in_new_tab**.",
                        Title = "On-call notes",
                        Settings = new Elasticstack.Inputs.KibanaDashboardPanelMarkdownConfigByValueSettingsArgs
                        {
                            OpenLinksInNewTab = true,
                        },
                    },
                },
            },
        },
    });

    // By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
    // or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
    // markdown library items today.
    var markdownByReference = new Elasticstack.KibanaDashboard("markdown_by_reference", new()
    {
        Title = "Dashboard with markdown (by-reference)",
        Description = "Example: markdown_config.by_reference with a placeholder ref_id",
        TimeRange = new Elasticstack.Inputs.KibanaDashboardTimeRangeArgs
        {
            From = "now-15m",
            To = "now",
        },
        RefreshInterval = new Elasticstack.Inputs.KibanaDashboardRefreshIntervalArgs
        {
            Pause = true,
            Value = 0,
        },
        Query = new Elasticstack.Inputs.KibanaDashboardQueryArgs
        {
            Language = "kql",
            Text = "",
        },
        Panels = new[]
        {
            new Elasticstack.Inputs.KibanaDashboardPanelArgs
            {
                Type = "markdown",
                Grid = new Elasticstack.Inputs.KibanaDashboardPanelGridArgs
                {
                    X = 0,
                    Y = 0,
                    W = 24,
                    H = 10,
                },
                MarkdownConfig = new Elasticstack.Inputs.KibanaDashboardPanelMarkdownConfigArgs
                {
                    ByReference = new Elasticstack.Inputs.KibanaDashboardPanelMarkdownConfigByReferenceArgs
                    {
                        RefId = "REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID",
                        Title = "Title overlay for library markdown",
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.KibanaDashboard;
import com.pulumi.elasticstack.KibanaDashboardArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardTimeRangeArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardRefreshIntervalArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardQueryArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelGridArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelVisConfigArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelVisConfigByValueArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelVisConfigByValueMetricChartConfigArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelVisConfigByValueMetricChartConfigQueryArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelMarkdownConfigArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelMarkdownConfigByValueArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelMarkdownConfigByValueSettingsArgs;
import com.pulumi.elasticstack.inputs.KibanaDashboardPanelMarkdownConfigByReferenceArgs;
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 myDashboard = new KibanaDashboard("myDashboard", KibanaDashboardArgs.builder()
            .title("My Dashboard")
            .description("A dashboard showing key metrics")
            .timeRange(KibanaDashboardTimeRangeArgs.builder()
                .from("now-15m")
                .to("now")
                .build())
            .refreshInterval(KibanaDashboardRefreshIntervalArgs.builder()
                .pause(false)
                .value(60000.0)
                .build())
            .query(KibanaDashboardQueryArgs.builder()
                .language("kql")
                .text("status:success")
                .build())
            .tags(            
                "production",
                "monitoring")
            .build());

        // Example with JSON query (mutually exclusive with query.text)
        var myDashboardJson = new KibanaDashboard("myDashboardJson", KibanaDashboardArgs.builder()
            .title("My Dashboard with JSON Query")
            .description("A dashboard with a structured query")
            .timeRange(KibanaDashboardTimeRangeArgs.builder()
                .from("now-15m")
                .to("now")
                .build())
            .refreshInterval(KibanaDashboardRefreshIntervalArgs.builder()
                .pause(false)
                .value(60000.0)
                .build())
            .query(KibanaDashboardQueryArgs.builder()
                .language("kql")
                .json(serializeJson(
                    jsonObject(
                        jsonProperty("bool", jsonObject(
                            jsonProperty("must", jsonArray(jsonObject(
                                jsonProperty("match", jsonObject(
                                    jsonProperty("status", "success")
                                ))
                            )))
                        ))
                    )))
                .build())
            .tags(            
                "production",
                "monitoring")
            .build());

        // Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
        var visTypedByValue = new KibanaDashboard("visTypedByValue", KibanaDashboardArgs.builder()
            .title("Dashboard with vis (typed by-value)")
            .description("Example: metric via vis_config.by_value.metric_chart_config")
            .timeRange(KibanaDashboardTimeRangeArgs.builder()
                .from("now-15m")
                .to("now")
                .build())
            .refreshInterval(KibanaDashboardRefreshIntervalArgs.builder()
                .pause(true)
                .value(0.0)
                .build())
            .query(KibanaDashboardQueryArgs.builder()
                .language("kql")
                .text("")
                .build())
            .panels(KibanaDashboardPanelArgs.builder()
                .type("vis")
                .grid(KibanaDashboardPanelGridArgs.builder()
                    .x(0.0)
                    .y(0.0)
                    .w(24.0)
                    .h(15.0)
                    .build())
                .visConfig(KibanaDashboardPanelVisConfigArgs.builder()
                    .byValue(KibanaDashboardPanelVisConfigByValueArgs.builder()
                        .metricChartConfig(KibanaDashboardPanelVisConfigByValueMetricChartConfigArgs.builder()
                            .dataSourceJson(serializeJson(
                                jsonObject(
                                    jsonProperty("type", "data_view_spec"),
                                    jsonProperty("index_pattern", "metrics-*"),
                                    jsonProperty("time_field", "@timestamp")
                                )))
                            .query(KibanaDashboardPanelVisConfigByValueMetricChartConfigQueryArgs.builder()
                                .expression("")
                                .build())
                            .metrics(KibanaDashboardPanelVisConfigByValueMetricChartConfigMetricArgs.builder()
                                .configJson(serializeJson(
                                    jsonObject(
                                        jsonProperty("type", "primary"),
                                        jsonProperty("operation", "count"),
                                        jsonProperty("format", jsonObject(
                                            jsonProperty("type", "number")
                                        ))
                                    )))
                                .build())
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        // Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
        // (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
        // Kibana API (link behavior via `open_links_in_new_tab`).
        var markdownByValue = new KibanaDashboard("markdownByValue", KibanaDashboardArgs.builder()
            .title("Dashboard with markdown (by-value)")
            .description("Example: markdown_config.by_value with settings")
            .timeRange(KibanaDashboardTimeRangeArgs.builder()
                .from("now-15m")
                .to("now")
                .build())
            .refreshInterval(KibanaDashboardRefreshIntervalArgs.builder()
                .pause(true)
                .value(0.0)
                .build())
            .query(KibanaDashboardQueryArgs.builder()
                .language("kql")
                .text("")
                .build())
            .panels(KibanaDashboardPanelArgs.builder()
                .type("markdown")
                .grid(KibanaDashboardPanelGridArgs.builder()
                    .x(0.0)
                    .y(0.0)
                    .w(24.0)
                    .h(10.0)
                    .build())
                .markdownConfig(KibanaDashboardPanelMarkdownConfigArgs.builder()
                    .byValue(KibanaDashboardPanelMarkdownConfigByValueArgs.builder()
                        .content("""
# Runbook

Links respect **open_links_in_new_tab**.                        """)
                        .title("On-call notes")
                        .settings(KibanaDashboardPanelMarkdownConfigByValueSettingsArgs.builder()
                            .openLinksInNewTab(true)
                            .build())
                        .build())
                    .build())
                .build())
            .build());

        // By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
        // or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
        // markdown library items today.
        var markdownByReference = new KibanaDashboard("markdownByReference", KibanaDashboardArgs.builder()
            .title("Dashboard with markdown (by-reference)")
            .description("Example: markdown_config.by_reference with a placeholder ref_id")
            .timeRange(KibanaDashboardTimeRangeArgs.builder()
                .from("now-15m")
                .to("now")
                .build())
            .refreshInterval(KibanaDashboardRefreshIntervalArgs.builder()
                .pause(true)
                .value(0.0)
                .build())
            .query(KibanaDashboardQueryArgs.builder()
                .language("kql")
                .text("")
                .build())
            .panels(KibanaDashboardPanelArgs.builder()
                .type("markdown")
                .grid(KibanaDashboardPanelGridArgs.builder()
                    .x(0.0)
                    .y(0.0)
                    .w(24.0)
                    .h(10.0)
                    .build())
                .markdownConfig(KibanaDashboardPanelMarkdownConfigArgs.builder()
                    .byReference(KibanaDashboardPanelMarkdownConfigByReferenceArgs.builder()
                        .refId("REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID")
                        .title("Title overlay for library markdown")
                        .build())
                    .build())
                .build())
            .build());

    }
}

resources:
  myDashboard:
    type: elasticstack:KibanaDashboard
    name: my_dashboard
    properties:
      title: My Dashboard
      description: A dashboard showing key metrics
      timeRange:
        from: now-15m
        to: now
      refreshInterval:
        pause: false
        value: 60000
      query:
        language: kql
        text: status:success
      tags:
        - production
        - monitoring
  # Example with JSON query (mutually exclusive with query.text)
  myDashboardJson:
    type: elasticstack:KibanaDashboard
    name: my_dashboard_json
    properties:
      title: My Dashboard with JSON Query
      description: A dashboard with a structured query
      timeRange:
        from: now-15m
        to: now
      refreshInterval:
        pause: false
        value: 60000
      query:
        language: kql
        json:
          fn::toJSON:
            bool:
              must:
                - match:
                    status: success
      tags:
        - production
        - monitoring
  # Classic Lens (`vis`) panel: typed by-value metric chart under `vis_config.by_value`.
  visTypedByValue:
    type: elasticstack:KibanaDashboard
    name: vis_typed_by_value
    properties:
      title: Dashboard with vis (typed by-value)
      description: 'Example: metric via vis_config.by_value.metric_chart_config'
      timeRange:
        from: now-15m
        to: now
      refreshInterval:
        pause: true
        value: 0
      query:
        language: kql
        text: ""
      panels:
        - type: vis
          grid:
            x: 0
            y: 0
            w: 24
            h: 15
          visConfig:
            byValue:
              metricChartConfig:
                dataSourceJson:
                  fn::toJSON:
                    type: data_view_spec
                    index_pattern: metrics-*
                    time_field: '@timestamp'
                query:
                  expression: ""
                metrics:
                  - configJson:
                      fn::toJSON:
                        type: primary
                        operation: count
                        format:
                          type: number
  # Markdown panel: `markdown_config` is a union — use `by_value` (inline content) or `by_reference`
  # (a library item via `ref_id`), not both. By-value panels require a `settings` object per the
  # Kibana API (link behavior via `open_links_in_new_tab`).
  markdownByValue:
    type: elasticstack:KibanaDashboard
    name: markdown_by_value
    properties:
      title: Dashboard with markdown (by-value)
      description: 'Example: markdown_config.by_value with settings'
      timeRange:
        from: now-15m
        to: now
      refreshInterval:
        pause: true
        value: 0
      query:
        language: kql
        text: ""
      panels:
        - type: markdown
          grid:
            x: 0
            y: 0
            w: 24
            h: 10
          markdownConfig:
            byValue:
              content: |-
                # Runbook

                Links respect **open_links_in_new_tab**.
              title: On-call notes
              settings:
                openLinksInNewTab: true
  # By-reference links a markdown *library* item. Create that saved object out-of-band (Kibana UI
  # or API) and substitute a real id for `ref_id` — there is no dedicated Terraform resource for
  # markdown library items today.
  markdownByReference:
    type: elasticstack:KibanaDashboard
    name: markdown_by_reference
    properties:
      title: Dashboard with markdown (by-reference)
      description: 'Example: markdown_config.by_reference with a placeholder ref_id'
      timeRange:
        from: now-15m
        to: now
      refreshInterval:
        pause: true
        value: 0
      query:
        language: kql
        text: ""
      panels:
        - type: markdown
          grid:
            x: 0
            y: 0
            w: 24
            h: 10
          markdownConfig:
            byReference:
              refId: REPLACE_WITH_MARKDOWN_LIBRARY_ITEM_ID
              title: Title overlay for library markdown