datasource_panel_heatmap_gen.go

// Code generated - EDITING IS FUTILE. DO NOT EDIT.
//
// Generated by pipeline:
//     terraform
// Using jennies:
//     TerraformDataSourceJenny
//     ComposableLatestMajorsOrXJenny
//
// Run 'go generate ./' from repository root to regenerate.

package provider

import (
	"context"
	"encoding/json"
	"strconv"

	"github.com/hashicorp/terraform-plugin-framework/attr"
	"github.com/hashicorp/terraform-plugin-framework/datasource"
	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/types"
	"github.com/hashicorp/terraform-plugin-log/tflog"
)

// Ensure that the imports are used to avoid compiler errors.
var _ attr.Value
var _ diag.Diagnostic

// Ensure provider defined types fully satisfy framework interfaces.
var (
	_ datasource.DataSource              = &PanelHeatmapDataSource{}
	_ datasource.DataSourceWithConfigure = &PanelHeatmapDataSource{}
)

func NewPanelHeatmapDataSource() datasource.DataSource {
	return &PanelHeatmapDataSource{}
}

// PanelHeatmapDataSource defines the data source implementation.
type PanelHeatmapDataSource struct{}

type PanelHeatmapDataSourceModel_Datasource struct {
	Type types.String `tfsdk:"type"`
	Uid  types.String `tfsdk:"uid"`
}

func (m PanelHeatmapDataSourceModel_Datasource) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Datasource struct {
		Type *string `json:"type,omitempty"`
		Uid  *string `json:"uid,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueStringPointer()
	attr_uid := m.Uid.ValueStringPointer()

	model := &jsonPanelHeatmapDataSourceModel_Datasource{
		Type: attr_type,
		Uid:  attr_uid,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Datasource) ApplyDefaults() PanelHeatmapDataSourceModel_Datasource {

	return m
}

type PanelHeatmapDataSourceModel_GridPos struct {
	H      types.Int64 `tfsdk:"h"`
	W      types.Int64 `tfsdk:"w"`
	X      types.Int64 `tfsdk:"x"`
	Y      types.Int64 `tfsdk:"y"`
	Static types.Bool  `tfsdk:"static"`
}

func (m PanelHeatmapDataSourceModel_GridPos) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_GridPos struct {
		H      int64 `json:"h"`
		W      int64 `json:"w"`
		X      int64 `json:"x"`
		Y      int64 `json:"y"`
		Static *bool `json:"static,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_h := m.H.ValueInt64()
	attr_w := m.W.ValueInt64()
	attr_x := m.X.ValueInt64()
	attr_y := m.Y.ValueInt64()
	attr_static := m.Static.ValueBoolPointer()

	model := &jsonPanelHeatmapDataSourceModel_GridPos{
		H:      attr_h,
		W:      attr_w,
		X:      attr_x,
		Y:      attr_y,
		Static: attr_static,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_GridPos) ApplyDefaults() PanelHeatmapDataSourceModel_GridPos {
	if m.H.IsNull() {
		m.H = types.Int64Value(9)
	}
	if m.W.IsNull() {
		m.W = types.Int64Value(12)
	}
	if m.X.IsNull() {
		m.X = types.Int64Value(0)
	}
	if m.Y.IsNull() {
		m.Y = types.Int64Value(0)
	}
	return m
}

type PanelHeatmapDataSourceModel_Links struct {
	Title       types.String `tfsdk:"title"`
	Type        types.String `tfsdk:"type"`
	Icon        types.String `tfsdk:"icon"`
	Tooltip     types.String `tfsdk:"tooltip"`
	Url         types.String `tfsdk:"url"`
	Tags        types.List   `tfsdk:"tags"`
	AsDropdown  types.Bool   `tfsdk:"as_dropdown"`
	TargetBlank types.Bool   `tfsdk:"target_blank"`
	IncludeVars types.Bool   `tfsdk:"include_vars"`
	KeepTime    types.Bool   `tfsdk:"keep_time"`
}

func (m PanelHeatmapDataSourceModel_Links) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Links struct {
		Title       string   `json:"title"`
		Type        string   `json:"type"`
		Icon        string   `json:"icon"`
		Tooltip     string   `json:"tooltip"`
		Url         string   `json:"url"`
		Tags        []string `json:"tags,omitempty"`
		AsDropdown  bool     `json:"asDropdown"`
		TargetBlank bool     `json:"targetBlank"`
		IncludeVars bool     `json:"includeVars"`
		KeepTime    bool     `json:"keepTime"`
	}

	m = m.ApplyDefaults()
	attr_title := m.Title.ValueString()
	attr_type := m.Type.ValueString()
	attr_icon := m.Icon.ValueString()
	attr_tooltip := m.Tooltip.ValueString()
	attr_url := m.Url.ValueString()
	attr_tags := []string{}
	for _, v := range m.Tags.Elements() {
		attr_tags = append(attr_tags, v.(types.String).ValueString())
	}
	attr_asdropdown := m.AsDropdown.ValueBool()
	attr_targetblank := m.TargetBlank.ValueBool()
	attr_includevars := m.IncludeVars.ValueBool()
	attr_keeptime := m.KeepTime.ValueBool()

	model := &jsonPanelHeatmapDataSourceModel_Links{
		Title:       attr_title,
		Type:        attr_type,
		Icon:        attr_icon,
		Tooltip:     attr_tooltip,
		Url:         attr_url,
		Tags:        attr_tags,
		AsDropdown:  attr_asdropdown,
		TargetBlank: attr_targetblank,
		IncludeVars: attr_includevars,
		KeepTime:    attr_keeptime,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Links) ApplyDefaults() PanelHeatmapDataSourceModel_Links {
	if len(m.Tags.Elements()) == 0 {
		m.Tags, _ = types.ListValue(types.StringType, []attr.Value{})
	}
	if m.AsDropdown.IsNull() {
		m.AsDropdown = types.BoolValue(false)
	}
	if m.TargetBlank.IsNull() {
		m.TargetBlank = types.BoolValue(false)
	}
	if m.IncludeVars.IsNull() {
		m.IncludeVars = types.BoolValue(false)
	}
	if m.KeepTime.IsNull() {
		m.KeepTime = types.BoolValue(false)
	}
	return m
}

type PanelHeatmapDataSourceModel_Transformations_Filter struct {
}

func (m PanelHeatmapDataSourceModel_Transformations_Filter) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Transformations_Filter struct {
	}

	m = m.ApplyDefaults()

	model := &jsonPanelHeatmapDataSourceModel_Transformations_Filter{}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Transformations_Filter) ApplyDefaults() PanelHeatmapDataSourceModel_Transformations_Filter {

	return m
}

type PanelHeatmapDataSourceModel_Transformations struct {
	Disabled types.Bool                                          `tfsdk:"disabled"`
	Filter   *PanelHeatmapDataSourceModel_Transformations_Filter `tfsdk:"filter"`
}

func (m PanelHeatmapDataSourceModel_Transformations) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Transformations struct {
		Disabled *bool       `json:"disabled,omitempty"`
		Filter   interface{} `json:"filter,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_disabled := m.Disabled.ValueBoolPointer()
	var attr_filter interface{}
	if m.Filter != nil {
		attr_filter = m.Filter
	}

	model := &jsonPanelHeatmapDataSourceModel_Transformations{
		Disabled: attr_disabled,
		Filter:   attr_filter,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Transformations) ApplyDefaults() PanelHeatmapDataSourceModel_Transformations {

	return m
}

type PanelHeatmapDataSourceModel_LibraryPanel struct {
	Name types.String `tfsdk:"name"`
	Uid  types.String `tfsdk:"uid"`
}

func (m PanelHeatmapDataSourceModel_LibraryPanel) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_LibraryPanel struct {
		Name string `json:"name"`
		Uid  string `json:"uid"`
	}

	m = m.ApplyDefaults()
	attr_name := m.Name.ValueString()
	attr_uid := m.Uid.ValueString()

	model := &jsonPanelHeatmapDataSourceModel_LibraryPanel{
		Name: attr_name,
		Uid:  attr_uid,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_LibraryPanel) ApplyDefaults() PanelHeatmapDataSourceModel_LibraryPanel {

	return m
}

type PanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale struct {
	Type            types.String  `tfsdk:"type"`
	Log             types.Float64 `tfsdk:"log"`
	LinearThreshold types.Float64 `tfsdk:"linear_threshold"`
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale struct {
		Type            string   `json:"type"`
		Log             *float64 `json:"log,omitempty"`
		LinearThreshold *float64 `json:"linearThreshold,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	attr_log := m.Log.ValueFloat64Pointer()
	attr_linearthreshold := m.LinearThreshold.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale{
		Type:            attr_type,
		Log:             attr_log,
		LinearThreshold: attr_linearthreshold,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale {

	return m
}

type PanelHeatmapDataSourceModel_Options_Calculation_XBuckets struct {
	Mode  types.String                                                    `tfsdk:"mode"`
	Value types.String                                                    `tfsdk:"value"`
	Scale *PanelHeatmapDataSourceModel_Options_Calculation_XBuckets_Scale `tfsdk:"scale"`
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_XBuckets) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Calculation_XBuckets struct {
		Mode  *string     `json:"mode,omitempty"`
		Value *string     `json:"value,omitempty"`
		Scale interface{} `json:"scale,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueStringPointer()
	attr_value := m.Value.ValueStringPointer()
	var attr_scale interface{}
	if m.Scale != nil {
		attr_scale = m.Scale
	}

	model := &jsonPanelHeatmapDataSourceModel_Options_Calculation_XBuckets{
		Mode:  attr_mode,
		Value: attr_value,
		Scale: attr_scale,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_XBuckets) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Calculation_XBuckets {

	return m
}

type PanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale struct {
	Type            types.String  `tfsdk:"type"`
	Log             types.Float64 `tfsdk:"log"`
	LinearThreshold types.Float64 `tfsdk:"linear_threshold"`
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale struct {
		Type            string   `json:"type"`
		Log             *float64 `json:"log,omitempty"`
		LinearThreshold *float64 `json:"linearThreshold,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	attr_log := m.Log.ValueFloat64Pointer()
	attr_linearthreshold := m.LinearThreshold.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale{
		Type:            attr_type,
		Log:             attr_log,
		LinearThreshold: attr_linearthreshold,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale {

	return m
}

type PanelHeatmapDataSourceModel_Options_Calculation_YBuckets struct {
	Mode  types.String                                                    `tfsdk:"mode"`
	Value types.String                                                    `tfsdk:"value"`
	Scale *PanelHeatmapDataSourceModel_Options_Calculation_YBuckets_Scale `tfsdk:"scale"`
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_YBuckets) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Calculation_YBuckets struct {
		Mode  *string     `json:"mode,omitempty"`
		Value *string     `json:"value,omitempty"`
		Scale interface{} `json:"scale,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueStringPointer()
	attr_value := m.Value.ValueStringPointer()
	var attr_scale interface{}
	if m.Scale != nil {
		attr_scale = m.Scale
	}

	model := &jsonPanelHeatmapDataSourceModel_Options_Calculation_YBuckets{
		Mode:  attr_mode,
		Value: attr_value,
		Scale: attr_scale,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Calculation_YBuckets) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Calculation_YBuckets {

	return m
}

type PanelHeatmapDataSourceModel_Options_Calculation struct {
	XBuckets *PanelHeatmapDataSourceModel_Options_Calculation_XBuckets `tfsdk:"x_buckets"`
	YBuckets *PanelHeatmapDataSourceModel_Options_Calculation_YBuckets `tfsdk:"y_buckets"`
}

func (m PanelHeatmapDataSourceModel_Options_Calculation) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Calculation struct {
		XBuckets interface{} `json:"xBuckets,omitempty"`
		YBuckets interface{} `json:"yBuckets,omitempty"`
	}

	m = m.ApplyDefaults()
	var attr_xbuckets interface{}
	if m.XBuckets != nil {
		attr_xbuckets = m.XBuckets
	}
	var attr_ybuckets interface{}
	if m.YBuckets != nil {
		attr_ybuckets = m.YBuckets
	}

	model := &jsonPanelHeatmapDataSourceModel_Options_Calculation{
		XBuckets: attr_xbuckets,
		YBuckets: attr_ybuckets,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Calculation) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Calculation {

	return m
}

type PanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions struct {
	Mode     types.String  `tfsdk:"mode"`
	Scheme   types.String  `tfsdk:"scheme"`
	Fill     types.String  `tfsdk:"fill"`
	Scale    types.String  `tfsdk:"scale"`
	Exponent types.Float64 `tfsdk:"exponent"`
	Steps    types.Int64   `tfsdk:"steps"`
	Reverse  types.Bool    `tfsdk:"reverse"`
	Min      types.Float64 `tfsdk:"min"`
	Max      types.Float64 `tfsdk:"max"`
}

func (m PanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions struct {
		Mode     *string  `json:"mode,omitempty"`
		Scheme   string   `json:"scheme"`
		Fill     string   `json:"fill"`
		Scale    *string  `json:"scale,omitempty"`
		Exponent float64  `json:"exponent"`
		Steps    int64    `json:"steps"`
		Reverse  bool     `json:"reverse"`
		Min      *float64 `json:"min,omitempty"`
		Max      *float64 `json:"max,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueStringPointer()
	attr_scheme := m.Scheme.ValueString()
	attr_fill := m.Fill.ValueString()
	attr_scale := m.Scale.ValueStringPointer()
	attr_exponent := m.Exponent.ValueFloat64()
	attr_steps := m.Steps.ValueInt64()
	attr_reverse := m.Reverse.ValueBool()
	attr_min := m.Min.ValueFloat64Pointer()
	attr_max := m.Max.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions{
		Mode:     attr_mode,
		Scheme:   attr_scheme,
		Fill:     attr_fill,
		Scale:    attr_scale,
		Exponent: attr_exponent,
		Steps:    attr_steps,
		Reverse:  attr_reverse,
		Min:      attr_min,
		Max:      attr_max,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions {

	return m
}

type PanelHeatmapDataSourceModel_Options_Color struct {
	HeatmapColorOptions *PanelHeatmapDataSourceModel_Options_Color_HeatmapColorOptions `tfsdk:"heatmap_color_options"`
}

func (m PanelHeatmapDataSourceModel_Options_Color) MarshalJSON() ([]byte, error) {
	var json_PanelHeatmapDataSourceModel_Options_Color interface{}
	m = m.ApplyDefaults()
	if m.HeatmapColorOptions != nil {
		json_PanelHeatmapDataSourceModel_Options_Color = m.HeatmapColorOptions
	}

	return json.Marshal(json_PanelHeatmapDataSourceModel_Options_Color)
}

func (m PanelHeatmapDataSourceModel_Options_Color) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Color {

	return m
}

type PanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange struct {
	Le types.Float64 `tfsdk:"le"`
	Ge types.Float64 `tfsdk:"ge"`
}

func (m PanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange struct {
		Le *float64 `json:"le,omitempty"`
		Ge *float64 `json:"ge,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_le := m.Le.ValueFloat64Pointer()
	attr_ge := m.Ge.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange{
		Le: attr_le,
		Ge: attr_ge,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange) ApplyDefaults() PanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange {

	return m
}

type PanelHeatmapDataSourceModel_Options_FilterValues struct {
	FilterValueRange *PanelHeatmapDataSourceModel_Options_FilterValues_FilterValueRange `tfsdk:"filter_value_range"`
}

func (m PanelHeatmapDataSourceModel_Options_FilterValues) MarshalJSON() ([]byte, error) {
	var json_PanelHeatmapDataSourceModel_Options_FilterValues interface{}
	m = m.ApplyDefaults()
	if m.FilterValueRange != nil {
		json_PanelHeatmapDataSourceModel_Options_FilterValues = m.FilterValueRange
	}

	return json.Marshal(json_PanelHeatmapDataSourceModel_Options_FilterValues)
}

func (m PanelHeatmapDataSourceModel_Options_FilterValues) ApplyDefaults() PanelHeatmapDataSourceModel_Options_FilterValues {

	return m
}

type PanelHeatmapDataSourceModel_Options_RowsFrame struct {
	Value  types.String `tfsdk:"value"`
	Layout types.String `tfsdk:"layout"`
}

func (m PanelHeatmapDataSourceModel_Options_RowsFrame) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_RowsFrame struct {
		Value  *string `json:"value,omitempty"`
		Layout *string `json:"layout,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_value := m.Value.ValueStringPointer()
	attr_layout := m.Layout.ValueStringPointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_RowsFrame{
		Value:  attr_value,
		Layout: attr_layout,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_RowsFrame) ApplyDefaults() PanelHeatmapDataSourceModel_Options_RowsFrame {

	return m
}

type PanelHeatmapDataSourceModel_Options_CellValues_CellValues struct {
	Unit     types.String  `tfsdk:"unit"`
	Decimals types.Float64 `tfsdk:"decimals"`
}

func (m PanelHeatmapDataSourceModel_Options_CellValues_CellValues) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_CellValues_CellValues struct {
		Unit     *string  `json:"unit,omitempty"`
		Decimals *float64 `json:"decimals,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_unit := m.Unit.ValueStringPointer()
	attr_decimals := m.Decimals.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_CellValues_CellValues{
		Unit:     attr_unit,
		Decimals: attr_decimals,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_CellValues_CellValues) ApplyDefaults() PanelHeatmapDataSourceModel_Options_CellValues_CellValues {

	return m
}

type PanelHeatmapDataSourceModel_Options_CellValues struct {
	CellValues *PanelHeatmapDataSourceModel_Options_CellValues_CellValues `tfsdk:"cell_values"`
}

func (m PanelHeatmapDataSourceModel_Options_CellValues) MarshalJSON() ([]byte, error) {
	var json_PanelHeatmapDataSourceModel_Options_CellValues interface{}
	m = m.ApplyDefaults()
	if m.CellValues != nil {
		json_PanelHeatmapDataSourceModel_Options_CellValues = m.CellValues
	}

	return json.Marshal(json_PanelHeatmapDataSourceModel_Options_CellValues)
}

func (m PanelHeatmapDataSourceModel_Options_CellValues) ApplyDefaults() PanelHeatmapDataSourceModel_Options_CellValues {

	return m
}

type PanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution struct {
	Type            types.String  `tfsdk:"type"`
	Log             types.Float64 `tfsdk:"log"`
	LinearThreshold types.Float64 `tfsdk:"linear_threshold"`
}

func (m PanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution struct {
		Type            string   `json:"type"`
		Log             *float64 `json:"log,omitempty"`
		LinearThreshold *float64 `json:"linearThreshold,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	attr_log := m.Log.ValueFloat64Pointer()
	attr_linearthreshold := m.LinearThreshold.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution{
		Type:            attr_type,
		Log:             attr_log,
		LinearThreshold: attr_linearthreshold,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution) ApplyDefaults() PanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution {

	return m
}

type PanelHeatmapDataSourceModel_Options_YAxis struct {
	Unit              types.String                                                 `tfsdk:"unit"`
	Reverse           types.Bool                                                   `tfsdk:"reverse"`
	Decimals          types.Float64                                                `tfsdk:"decimals"`
	Min               types.Float64                                                `tfsdk:"min"`
	AxisPlacement     types.String                                                 `tfsdk:"axis_placement"`
	AxisColorMode     types.String                                                 `tfsdk:"axis_color_mode"`
	AxisLabel         types.String                                                 `tfsdk:"axis_label"`
	AxisWidth         types.Float64                                                `tfsdk:"axis_width"`
	AxisSoftMin       types.Float64                                                `tfsdk:"axis_soft_min"`
	AxisSoftMax       types.Float64                                                `tfsdk:"axis_soft_max"`
	AxisGridShow      types.Bool                                                   `tfsdk:"axis_grid_show"`
	ScaleDistribution *PanelHeatmapDataSourceModel_Options_YAxis_ScaleDistribution `tfsdk:"scale_distribution"`
	Max               types.Float64                                                `tfsdk:"max"`
	AxisCenteredZero  types.Bool                                                   `tfsdk:"axis_centered_zero"`
}

func (m PanelHeatmapDataSourceModel_Options_YAxis) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_YAxis struct {
		Unit              *string     `json:"unit,omitempty"`
		Reverse           *bool       `json:"reverse,omitempty"`
		Decimals          *float64    `json:"decimals,omitempty"`
		Min               *float64    `json:"min,omitempty"`
		AxisPlacement     *string     `json:"axisPlacement,omitempty"`
		AxisColorMode     *string     `json:"axisColorMode,omitempty"`
		AxisLabel         *string     `json:"axisLabel,omitempty"`
		AxisWidth         *float64    `json:"axisWidth,omitempty"`
		AxisSoftMin       *float64    `json:"axisSoftMin,omitempty"`
		AxisSoftMax       *float64    `json:"axisSoftMax,omitempty"`
		AxisGridShow      *bool       `json:"axisGridShow,omitempty"`
		ScaleDistribution interface{} `json:"scaleDistribution,omitempty"`
		Max               *float64    `json:"max,omitempty"`
		AxisCenteredZero  *bool       `json:"axisCenteredZero,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_unit := m.Unit.ValueStringPointer()
	attr_reverse := m.Reverse.ValueBoolPointer()
	attr_decimals := m.Decimals.ValueFloat64Pointer()
	attr_min := m.Min.ValueFloat64Pointer()
	attr_axisplacement := m.AxisPlacement.ValueStringPointer()
	attr_axiscolormode := m.AxisColorMode.ValueStringPointer()
	attr_axislabel := m.AxisLabel.ValueStringPointer()
	attr_axiswidth := m.AxisWidth.ValueFloat64Pointer()
	attr_axissoftmin := m.AxisSoftMin.ValueFloat64Pointer()
	attr_axissoftmax := m.AxisSoftMax.ValueFloat64Pointer()
	attr_axisgridshow := m.AxisGridShow.ValueBoolPointer()
	var attr_scaledistribution interface{}
	if m.ScaleDistribution != nil {
		attr_scaledistribution = m.ScaleDistribution
	}
	attr_max := m.Max.ValueFloat64Pointer()
	attr_axiscenteredzero := m.AxisCenteredZero.ValueBoolPointer()

	model := &jsonPanelHeatmapDataSourceModel_Options_YAxis{
		Unit:              attr_unit,
		Reverse:           attr_reverse,
		Decimals:          attr_decimals,
		Min:               attr_min,
		AxisPlacement:     attr_axisplacement,
		AxisColorMode:     attr_axiscolormode,
		AxisLabel:         attr_axislabel,
		AxisWidth:         attr_axiswidth,
		AxisSoftMin:       attr_axissoftmin,
		AxisSoftMax:       attr_axissoftmax,
		AxisGridShow:      attr_axisgridshow,
		ScaleDistribution: attr_scaledistribution,
		Max:               attr_max,
		AxisCenteredZero:  attr_axiscenteredzero,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_YAxis) ApplyDefaults() PanelHeatmapDataSourceModel_Options_YAxis {

	return m
}

type PanelHeatmapDataSourceModel_Options_Legend struct {
	Show types.Bool `tfsdk:"show"`
}

func (m PanelHeatmapDataSourceModel_Options_Legend) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Legend struct {
		Show bool `json:"show"`
	}

	m = m.ApplyDefaults()
	attr_show := m.Show.ValueBool()

	model := &jsonPanelHeatmapDataSourceModel_Options_Legend{
		Show: attr_show,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Legend) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Legend {

	return m
}

type PanelHeatmapDataSourceModel_Options_Tooltip struct {
	Show       types.Bool `tfsdk:"show"`
	YHistogram types.Bool `tfsdk:"y_histogram"`
}

func (m PanelHeatmapDataSourceModel_Options_Tooltip) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Tooltip struct {
		Show       bool `json:"show"`
		YHistogram bool `json:"yHistogram"`
	}

	m = m.ApplyDefaults()
	attr_show := m.Show.ValueBool()
	attr_yhistogram := m.YHistogram.ValueBool()

	model := &jsonPanelHeatmapDataSourceModel_Options_Tooltip{
		Show:       attr_show,
		YHistogram: attr_yhistogram,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Tooltip) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Tooltip {

	return m
}

type PanelHeatmapDataSourceModel_Options_Exemplars struct {
	Color types.String `tfsdk:"color"`
}

func (m PanelHeatmapDataSourceModel_Options_Exemplars) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options_Exemplars struct {
		Color string `json:"color"`
	}

	m = m.ApplyDefaults()
	attr_color := m.Color.ValueString()

	model := &jsonPanelHeatmapDataSourceModel_Options_Exemplars{
		Color: attr_color,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options_Exemplars) ApplyDefaults() PanelHeatmapDataSourceModel_Options_Exemplars {

	return m
}

type PanelHeatmapDataSourceModel_Options struct {
	Calculate    types.Bool                                        `tfsdk:"calculate"`
	Calculation  *PanelHeatmapDataSourceModel_Options_Calculation  `tfsdk:"calculation"`
	Color        *PanelHeatmapDataSourceModel_Options_Color        `tfsdk:"color"`
	FilterValues *PanelHeatmapDataSourceModel_Options_FilterValues `tfsdk:"filter_values"`
	RowsFrame    *PanelHeatmapDataSourceModel_Options_RowsFrame    `tfsdk:"rows_frame"`
	ShowValue    types.String                                      `tfsdk:"show_value"`
	CellGap      types.Int64                                       `tfsdk:"cell_gap"`
	CellRadius   types.Float64                                     `tfsdk:"cell_radius"`
	CellValues   *PanelHeatmapDataSourceModel_Options_CellValues   `tfsdk:"cell_values"`
	YAxis        *PanelHeatmapDataSourceModel_Options_YAxis        `tfsdk:"y_axis"`
	Legend       *PanelHeatmapDataSourceModel_Options_Legend       `tfsdk:"legend"`
	Tooltip      *PanelHeatmapDataSourceModel_Options_Tooltip      `tfsdk:"tooltip"`
	Exemplars    *PanelHeatmapDataSourceModel_Options_Exemplars    `tfsdk:"exemplars"`
}

func (m PanelHeatmapDataSourceModel_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_Options struct {
		Calculate    *bool       `json:"calculate,omitempty"`
		Calculation  interface{} `json:"calculation,omitempty"`
		Color        interface{} `json:"color,omitempty"`
		FilterValues interface{} `json:"filterValues,omitempty"`
		RowsFrame    interface{} `json:"rowsFrame,omitempty"`
		ShowValue    string      `json:"showValue"`
		CellGap      *int64      `json:"cellGap,omitempty"`
		CellRadius   *float64    `json:"cellRadius,omitempty"`
		CellValues   interface{} `json:"cellValues,omitempty"`
		YAxis        interface{} `json:"yAxis,omitempty"`
		Legend       interface{} `json:"legend,omitempty"`
		Tooltip      interface{} `json:"tooltip,omitempty"`
		Exemplars    interface{} `json:"exemplars,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_calculate := m.Calculate.ValueBoolPointer()
	var attr_calculation interface{}
	if m.Calculation != nil {
		attr_calculation = m.Calculation
	}
	var attr_color interface{}
	if m.Color != nil {
		attr_color = m.Color
	}
	var attr_filtervalues interface{}
	if m.FilterValues != nil {
		attr_filtervalues = m.FilterValues
	}
	var attr_rowsframe interface{}
	if m.RowsFrame != nil {
		attr_rowsframe = m.RowsFrame
	}
	attr_showvalue := m.ShowValue.ValueString()
	attr_cellgap := m.CellGap.ValueInt64Pointer()
	attr_cellradius := m.CellRadius.ValueFloat64Pointer()
	var attr_cellvalues interface{}
	if m.CellValues != nil {
		attr_cellvalues = m.CellValues
	}
	var attr_yaxis interface{}
	if m.YAxis != nil {
		attr_yaxis = m.YAxis
	}
	var attr_legend interface{}
	if m.Legend != nil {
		attr_legend = m.Legend
	}
	var attr_tooltip interface{}
	if m.Tooltip != nil {
		attr_tooltip = m.Tooltip
	}
	var attr_exemplars interface{}
	if m.Exemplars != nil {
		attr_exemplars = m.Exemplars
	}

	model := &jsonPanelHeatmapDataSourceModel_Options{
		Calculate:    attr_calculate,
		Calculation:  attr_calculation,
		Color:        attr_color,
		FilterValues: attr_filtervalues,
		RowsFrame:    attr_rowsframe,
		ShowValue:    attr_showvalue,
		CellGap:      attr_cellgap,
		CellRadius:   attr_cellradius,
		CellValues:   attr_cellvalues,
		YAxis:        attr_yaxis,
		Legend:       attr_legend,
		Tooltip:      attr_tooltip,
		Exemplars:    attr_exemplars,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_Options) ApplyDefaults() PanelHeatmapDataSourceModel_Options {
	if m.Calculate.IsNull() {
		m.Calculate = types.BoolValue(false)
	}
	if m.ShowValue.IsNull() {
		m.ShowValue = types.StringValue(`auto`)
	}
	if m.CellGap.IsNull() {
		m.CellGap = types.Int64Value(1)
	}
	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options struct {
	Text  types.String `tfsdk:"text"`
	Color types.String `tfsdk:"color"`
	Icon  types.String `tfsdk:"icon"`
	Index types.Int64  `tfsdk:"index"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options struct {
		Text  *string `json:"text,omitempty"`
		Color *string `json:"color,omitempty"`
		Icon  *string `json:"icon,omitempty"`
		Index *int64  `json:"index,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_text := m.Text.ValueStringPointer()
	attr_color := m.Color.ValueStringPointer()
	attr_icon := m.Icon.ValueStringPointer()
	attr_index := m.Index.ValueInt64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap struct {
	Type    types.String                                                                           `tfsdk:"type"`
	Options *map[string]PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options `tfsdk:"options"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap struct {
		Type    string      `json:"type"`
		Options interface{} `json:"options,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	var attr_options interface{}
	if m.Options != nil {
		attr_options = m.Options
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result struct {
	Text  types.String `tfsdk:"text"`
	Color types.String `tfsdk:"color"`
	Icon  types.String `tfsdk:"icon"`
	Index types.Int64  `tfsdk:"index"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result struct {
		Text  *string `json:"text,omitempty"`
		Color *string `json:"color,omitempty"`
		Icon  *string `json:"icon,omitempty"`
		Index *int64  `json:"index,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_text := m.Text.ValueStringPointer()
	attr_color := m.Color.ValueStringPointer()
	attr_icon := m.Icon.ValueStringPointer()
	attr_index := m.Index.ValueInt64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options struct {
	From   types.String                                                                       `tfsdk:"from"`
	To     types.String                                                                       `tfsdk:"to"`
	Result *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result `tfsdk:"result"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) GetAttrFrom() interface{} {
	var attr interface{}
	var err error

	attr, err = strconv.ParseFloat(m.From.ValueString(), 64)
	if err == nil {
		return attr
	}

	if err == nil {
		return attr
	}

	return m.From.ValueString()
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) GetAttrTo() interface{} {
	var attr interface{}
	var err error

	attr, err = strconv.ParseFloat(m.To.ValueString(), 64)
	if err == nil {
		return attr
	}

	if err == nil {
		return attr
	}

	return m.To.ValueString()
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options struct {
		From   interface{} `json:"from"`
		To     interface{} `json:"to"`
		Result interface{} `json:"result,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_from := m.GetAttrFrom()
	attr_to := m.GetAttrTo()
	var attr_result interface{}
	if m.Result != nil {
		attr_result = m.Result
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options{
		From:   attr_from,
		To:     attr_to,
		Result: attr_result,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap struct {
	Type    types.String                                                                `tfsdk:"type"`
	Options *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options `tfsdk:"options"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap struct {
		Type    string      `json:"type"`
		Options interface{} `json:"options,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	var attr_options interface{}
	if m.Options != nil {
		attr_options = m.Options
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result struct {
	Text  types.String `tfsdk:"text"`
	Color types.String `tfsdk:"color"`
	Icon  types.String `tfsdk:"icon"`
	Index types.Int64  `tfsdk:"index"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result struct {
		Text  *string `json:"text,omitempty"`
		Color *string `json:"color,omitempty"`
		Icon  *string `json:"icon,omitempty"`
		Index *int64  `json:"index,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_text := m.Text.ValueStringPointer()
	attr_color := m.Color.ValueStringPointer()
	attr_icon := m.Icon.ValueStringPointer()
	attr_index := m.Index.ValueInt64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options struct {
	Pattern types.String                                                                       `tfsdk:"pattern"`
	Result  *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result `tfsdk:"result"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options struct {
		Pattern string      `json:"pattern"`
		Result  interface{} `json:"result,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_pattern := m.Pattern.ValueString()
	var attr_result interface{}
	if m.Result != nil {
		attr_result = m.Result
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options{
		Pattern: attr_pattern,
		Result:  attr_result,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap struct {
	Type    types.String                                                                `tfsdk:"type"`
	Options *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options `tfsdk:"options"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap struct {
		Type    string      `json:"type"`
		Options interface{} `json:"options,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	var attr_options interface{}
	if m.Options != nil {
		attr_options = m.Options
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result struct {
	Text  types.String `tfsdk:"text"`
	Color types.String `tfsdk:"color"`
	Icon  types.String `tfsdk:"icon"`
	Index types.Int64  `tfsdk:"index"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result struct {
		Text  *string `json:"text,omitempty"`
		Color *string `json:"color,omitempty"`
		Icon  *string `json:"icon,omitempty"`
		Index *int64  `json:"index,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_text := m.Text.ValueStringPointer()
	attr_color := m.Color.ValueStringPointer()
	attr_icon := m.Icon.ValueStringPointer()
	attr_index := m.Index.ValueInt64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options struct {
	Match  types.String                                                                              `tfsdk:"match"`
	Result *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result `tfsdk:"result"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options struct {
		Match  string      `json:"match"`
		Result interface{} `json:"result,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_match := m.Match.ValueString()
	var attr_result interface{}
	if m.Result != nil {
		attr_result = m.Result
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options{
		Match:  attr_match,
		Result: attr_result,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap struct {
	Type    types.String                                                                       `tfsdk:"type"`
	Options *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options `tfsdk:"options"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap struct {
		Type    string      `json:"type"`
		Options interface{} `json:"options,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	var attr_options interface{}
	if m.Options != nil {
		attr_options = m.Options
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings struct {
	ValueMap        *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap        `tfsdk:"value_map"`
	RangeMap        *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap        `tfsdk:"range_map"`
	RegexMap        *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap        `tfsdk:"regex_map"`
	SpecialValueMap *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap `tfsdk:"special_value_map"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings) MarshalJSON() ([]byte, error) {
	var json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings interface{}
	m = m.ApplyDefaults()
	if m.ValueMap != nil {
		json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings = m.ValueMap
	}
	if m.RangeMap != nil {
		json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings = m.RangeMap
	}
	if m.RegexMap != nil {
		json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings = m.RegexMap
	}
	if m.SpecialValueMap != nil {
		json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings = m.SpecialValueMap
	}

	return json.Marshal(json_PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps struct {
	Value types.String `tfsdk:"value"`
	Color types.String `tfsdk:"color"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps) GetAttrValue() interface{} {
	var attr interface{}
	var err error

	attr, err = strconv.ParseFloat(m.Value.ValueString(), 64)
	if err == nil {
		return attr
	}

	if err == nil {
		return attr
	}

	return m.Value.ValueString()
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps struct {
		Value interface{} `json:"value"`
		Color string      `json:"color"`
	}

	m = m.ApplyDefaults()
	attr_value := m.GetAttrValue()
	attr_color := m.Color.ValueString()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps{
		Value: attr_value,
		Color: attr_color,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds struct {
	Mode  types.String                                                        `tfsdk:"mode"`
	Steps []PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds_Steps `tfsdk:"steps"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds struct {
		Mode  string        `json:"mode"`
		Steps []interface{} `json:"steps,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueString()
	attr_steps := []interface{}{}
	for _, v := range m.Steps {
		attr_steps = append(attr_steps, v)
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds{
		Mode:  attr_mode,
		Steps: attr_steps,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Color struct {
	Mode       types.String `tfsdk:"mode"`
	FixedColor types.String `tfsdk:"fixed_color"`
	SeriesBy   types.String `tfsdk:"series_by"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Color) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Color struct {
		Mode       string  `json:"mode"`
		FixedColor *string `json:"fixedColor,omitempty"`
		SeriesBy   *string `json:"seriesBy,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueString()
	attr_fixedcolor := m.FixedColor.ValueStringPointer()
	attr_seriesby := m.SeriesBy.ValueStringPointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Color{
		Mode:       attr_mode,
		FixedColor: attr_fixedcolor,
		SeriesBy:   attr_seriesby,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Color) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Color {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution struct {
	Type            types.String  `tfsdk:"type"`
	Log             types.Float64 `tfsdk:"log"`
	LinearThreshold types.Float64 `tfsdk:"linear_threshold"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution struct {
		Type            string   `json:"type"`
		Log             *float64 `json:"log,omitempty"`
		LinearThreshold *float64 `json:"linearThreshold,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	attr_log := m.Log.ValueFloat64Pointer()
	attr_linearthreshold := m.LinearThreshold.ValueFloat64Pointer()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution{
		Type:            attr_type,
		Log:             attr_log,
		LinearThreshold: attr_linearthreshold,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom struct {
	Tooltip types.Bool `tfsdk:"tooltip"`
	Legend  types.Bool `tfsdk:"legend"`
	Viz     types.Bool `tfsdk:"viz"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom struct {
		Tooltip bool `json:"tooltip"`
		Legend  bool `json:"legend"`
		Viz     bool `json:"viz"`
	}

	m = m.ApplyDefaults()
	attr_tooltip := m.Tooltip.ValueBool()
	attr_legend := m.Legend.ValueBool()
	attr_viz := m.Viz.ValueBool()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom{
		Tooltip: attr_tooltip,
		Legend:  attr_legend,
		Viz:     attr_viz,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom struct {
	ScaleDistribution *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution `tfsdk:"scale_distribution"`
	HideFrom          *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom_HideFrom          `tfsdk:"hide_from"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom struct {
		ScaleDistribution interface{} `json:"scaleDistribution,omitempty"`
		HideFrom          interface{} `json:"hideFrom,omitempty"`
	}

	m = m.ApplyDefaults()
	var attr_scaledistribution interface{}
	if m.ScaleDistribution != nil {
		attr_scaledistribution = m.ScaleDistribution
	}
	var attr_hidefrom interface{}
	if m.HideFrom != nil {
		attr_hidefrom = m.HideFrom
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom{
		ScaleDistribution: attr_scaledistribution,
		HideFrom:          attr_hidefrom,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Defaults struct {
	DisplayName       types.String                                                 `tfsdk:"display_name"`
	DisplayNameFromDS types.String                                                 `tfsdk:"display_name_from_ds"`
	Description       types.String                                                 `tfsdk:"description"`
	Path              types.String                                                 `tfsdk:"path"`
	Writeable         types.Bool                                                   `tfsdk:"writeable"`
	Filterable        types.Bool                                                   `tfsdk:"filterable"`
	Unit              types.String                                                 `tfsdk:"unit"`
	Decimals          types.Float64                                                `tfsdk:"decimals"`
	Min               types.Float64                                                `tfsdk:"min"`
	Max               types.Float64                                                `tfsdk:"max"`
	Mappings          []PanelHeatmapDataSourceModel_FieldConfig_Defaults_Mappings  `tfsdk:"mappings"`
	Thresholds        *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Thresholds `tfsdk:"thresholds"`
	Color             *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Color      `tfsdk:"color"`
	NoValue           types.String                                                 `tfsdk:"no_value"`
	Custom            *PanelHeatmapDataSourceModel_FieldConfig_Defaults_Custom     `tfsdk:"custom"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults struct {
		DisplayName       *string       `json:"displayName,omitempty"`
		DisplayNameFromDS *string       `json:"displayNameFromDS,omitempty"`
		Description       *string       `json:"description,omitempty"`
		Path              *string       `json:"path,omitempty"`
		Writeable         *bool         `json:"writeable,omitempty"`
		Filterable        *bool         `json:"filterable,omitempty"`
		Unit              *string       `json:"unit,omitempty"`
		Decimals          *float64      `json:"decimals,omitempty"`
		Min               *float64      `json:"min,omitempty"`
		Max               *float64      `json:"max,omitempty"`
		Mappings          []interface{} `json:"mappings,omitempty"`
		Thresholds        interface{}   `json:"thresholds,omitempty"`
		Color             interface{}   `json:"color,omitempty"`
		NoValue           *string       `json:"noValue,omitempty"`
		Custom            interface{}   `json:"custom,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_displayname := m.DisplayName.ValueStringPointer()
	attr_displaynamefromds := m.DisplayNameFromDS.ValueStringPointer()
	attr_description := m.Description.ValueStringPointer()
	attr_path := m.Path.ValueStringPointer()
	attr_writeable := m.Writeable.ValueBoolPointer()
	attr_filterable := m.Filterable.ValueBoolPointer()
	attr_unit := m.Unit.ValueStringPointer()
	attr_decimals := m.Decimals.ValueFloat64Pointer()
	attr_min := m.Min.ValueFloat64Pointer()
	attr_max := m.Max.ValueFloat64Pointer()
	attr_mappings := []interface{}{}
	for _, v := range m.Mappings {
		attr_mappings = append(attr_mappings, v)
	}
	var attr_thresholds interface{}
	if m.Thresholds != nil {
		attr_thresholds = m.Thresholds
	}
	var attr_color interface{}
	if m.Color != nil {
		attr_color = m.Color
	}
	attr_novalue := m.NoValue.ValueStringPointer()
	var attr_custom interface{}
	if m.Custom != nil {
		attr_custom = m.Custom
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Defaults{
		DisplayName:       attr_displayname,
		DisplayNameFromDS: attr_displaynamefromds,
		Description:       attr_description,
		Path:              attr_path,
		Writeable:         attr_writeable,
		Filterable:        attr_filterable,
		Unit:              attr_unit,
		Decimals:          attr_decimals,
		Min:               attr_min,
		Max:               attr_max,
		Mappings:          attr_mappings,
		Thresholds:        attr_thresholds,
		Color:             attr_color,
		NoValue:           attr_novalue,
		Custom:            attr_custom,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Defaults) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Defaults {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher struct {
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher struct {
	}

	m = m.ApplyDefaults()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher{}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties struct {
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties struct {
	}

	m = m.ApplyDefaults()

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties{}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig_Overrides struct {
	Matcher    *PanelHeatmapDataSourceModel_FieldConfig_Overrides_Matcher     `tfsdk:"matcher"`
	Properties []PanelHeatmapDataSourceModel_FieldConfig_Overrides_Properties `tfsdk:"properties"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides struct {
		Matcher    interface{}   `json:"matcher,omitempty"`
		Properties []interface{} `json:"properties,omitempty"`
	}

	m = m.ApplyDefaults()
	var attr_matcher interface{}
	if m.Matcher != nil {
		attr_matcher = m.Matcher
	}
	attr_properties := []interface{}{}
	for _, v := range m.Properties {
		attr_properties = append(attr_properties, v)
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig_Overrides{
		Matcher:    attr_matcher,
		Properties: attr_properties,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig_Overrides) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig_Overrides {

	return m
}

type PanelHeatmapDataSourceModel_FieldConfig struct {
	Defaults  *PanelHeatmapDataSourceModel_FieldConfig_Defaults   `tfsdk:"defaults"`
	Overrides []PanelHeatmapDataSourceModel_FieldConfig_Overrides `tfsdk:"overrides"`
}

func (m PanelHeatmapDataSourceModel_FieldConfig) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel_FieldConfig struct {
		Defaults  interface{}   `json:"defaults,omitempty"`
		Overrides []interface{} `json:"overrides,omitempty"`
	}

	m = m.ApplyDefaults()
	var attr_defaults interface{}
	if m.Defaults != nil {
		attr_defaults = m.Defaults
	}
	attr_overrides := []interface{}{}
	for _, v := range m.Overrides {
		attr_overrides = append(attr_overrides, v)
	}

	model := &jsonPanelHeatmapDataSourceModel_FieldConfig{
		Defaults:  attr_defaults,
		Overrides: attr_overrides,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel_FieldConfig) ApplyDefaults() PanelHeatmapDataSourceModel_FieldConfig {

	return m
}

type PanelHeatmapDataSourceModel struct {
	RenderedJSON    types.String                                  `tfsdk:"rendered_json"`
	Type            types.String                                  `tfsdk:"type"`
	PluginVersion   types.String                                  `tfsdk:"plugin_version"`
	Tags            types.List                                    `tfsdk:"tags"`
	Targets         types.List                                    `tfsdk:"targets"`
	Title           types.String                                  `tfsdk:"title"`
	Description     types.String                                  `tfsdk:"description"`
	Transparent     types.Bool                                    `tfsdk:"transparent"`
	Datasource      *PanelHeatmapDataSourceModel_Datasource       `tfsdk:"datasource"`
	GridPos         *PanelHeatmapDataSourceModel_GridPos          `tfsdk:"grid_pos"`
	Links           []PanelHeatmapDataSourceModel_Links           `tfsdk:"links"`
	Repeat          types.String                                  `tfsdk:"repeat"`
	RepeatDirection types.String                                  `tfsdk:"repeat_direction"`
	RepeatPanelId   types.Int64                                   `tfsdk:"repeat_panel_id"`
	MaxDataPoints   types.Float64                                 `tfsdk:"max_data_points"`
	Transformations []PanelHeatmapDataSourceModel_Transformations `tfsdk:"transformations"`
	Interval        types.String                                  `tfsdk:"interval"`
	TimeFrom        types.String                                  `tfsdk:"time_from"`
	TimeShift       types.String                                  `tfsdk:"time_shift"`
	LibraryPanel    *PanelHeatmapDataSourceModel_LibraryPanel     `tfsdk:"library_panel"`
	Options         *PanelHeatmapDataSourceModel_Options          `tfsdk:"options"`
	FieldConfig     *PanelHeatmapDataSourceModel_FieldConfig      `tfsdk:"field_config"`
}

func (m PanelHeatmapDataSourceModel) MarshalJSON() ([]byte, error) {
	type jsonPanelHeatmapDataSourceModel struct {
		Type            string        `json:"type"`
		PluginVersion   *string       `json:"pluginVersion,omitempty"`
		Tags            []string      `json:"tags,omitempty"`
		Targets         []string      `json:"targets,omitempty"`
		Title           *string       `json:"title,omitempty"`
		Description     *string       `json:"description,omitempty"`
		Transparent     bool          `json:"transparent"`
		Datasource      interface{}   `json:"datasource,omitempty"`
		GridPos         interface{}   `json:"gridPos,omitempty"`
		Links           []interface{} `json:"links,omitempty"`
		Repeat          *string       `json:"repeat,omitempty"`
		RepeatDirection *string       `json:"repeatDirection,omitempty"`
		RepeatPanelId   *int64        `json:"repeatPanelId,omitempty"`
		MaxDataPoints   *float64      `json:"maxDataPoints,omitempty"`
		Transformations []interface{} `json:"transformations,omitempty"`
		Interval        *string       `json:"interval,omitempty"`
		TimeFrom        *string       `json:"timeFrom,omitempty"`
		TimeShift       *string       `json:"timeShift,omitempty"`
		LibraryPanel    interface{}   `json:"libraryPanel,omitempty"`
		Options         interface{}   `json:"options,omitempty"`
		FieldConfig     interface{}   `json:"fieldConfig,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_type := m.Type.ValueString()
	attr_pluginversion := m.PluginVersion.ValueStringPointer()
	attr_tags := []string{}
	for _, v := range m.Tags.Elements() {
		attr_tags = append(attr_tags, v.(types.String).ValueString())
	}
	attr_targets := []string{}
	for _, v := range m.Targets.Elements() {
		attr_targets = append(attr_targets, v.(types.String).ValueString())
	}
	attr_title := m.Title.ValueStringPointer()
	attr_description := m.Description.ValueStringPointer()
	attr_transparent := m.Transparent.ValueBool()
	var attr_datasource interface{}
	if m.Datasource != nil {
		attr_datasource = m.Datasource
	}
	var attr_gridpos interface{}
	if m.GridPos != nil {
		attr_gridpos = m.GridPos
	}
	attr_links := []interface{}{}
	for _, v := range m.Links {
		attr_links = append(attr_links, v)
	}
	attr_repeat := m.Repeat.ValueStringPointer()
	attr_repeatdirection := m.RepeatDirection.ValueStringPointer()
	attr_repeatpanelid := m.RepeatPanelId.ValueInt64Pointer()
	attr_maxdatapoints := m.MaxDataPoints.ValueFloat64Pointer()
	attr_transformations := []interface{}{}
	for _, v := range m.Transformations {
		attr_transformations = append(attr_transformations, v)
	}
	attr_interval := m.Interval.ValueStringPointer()
	attr_timefrom := m.TimeFrom.ValueStringPointer()
	attr_timeshift := m.TimeShift.ValueStringPointer()
	var attr_librarypanel interface{}
	if m.LibraryPanel != nil {
		attr_librarypanel = m.LibraryPanel
	}
	var attr_options interface{}
	if m.Options != nil {
		attr_options = m.Options
	}
	var attr_fieldconfig interface{}
	if m.FieldConfig != nil {
		attr_fieldconfig = m.FieldConfig
	}

	model := &jsonPanelHeatmapDataSourceModel{
		Type:            attr_type,
		PluginVersion:   attr_pluginversion,
		Tags:            attr_tags,
		Targets:         attr_targets,
		Title:           attr_title,
		Description:     attr_description,
		Transparent:     attr_transparent,
		Datasource:      attr_datasource,
		GridPos:         attr_gridpos,
		Links:           attr_links,
		Repeat:          attr_repeat,
		RepeatDirection: attr_repeatdirection,
		RepeatPanelId:   attr_repeatpanelid,
		MaxDataPoints:   attr_maxdatapoints,
		Transformations: attr_transformations,
		Interval:        attr_interval,
		TimeFrom:        attr_timefrom,
		TimeShift:       attr_timeshift,
		LibraryPanel:    attr_librarypanel,
		Options:         attr_options,
		FieldConfig:     attr_fieldconfig,
	}
	return json.Marshal(model)
}

func (m PanelHeatmapDataSourceModel) ApplyDefaults() PanelHeatmapDataSourceModel {
	if m.Type.IsNull() {
		m.Type = types.StringValue(`heatmap`)
	}
	if len(m.Tags.Elements()) == 0 {
		m.Tags, _ = types.ListValue(types.StringType, []attr.Value{})
	}
	if len(m.Targets.Elements()) == 0 {
		m.Targets, _ = types.ListValue(types.StringType, []attr.Value{})
	}
	if m.Transparent.IsNull() {
		m.Transparent = types.BoolValue(false)
	}
	if m.RepeatDirection.IsNull() {
		m.RepeatDirection = types.StringValue(`h`)
	}
	return m
}

func (d *PanelHeatmapDataSource) Metadata(ctx context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
	resp.TypeName = req.ProviderTypeName + "_panel_heatmap"
}

func (d *PanelHeatmapDataSource) Schema(ctx context.Context, req datasource.SchemaRequest, resp *datasource.SchemaResponse) {
	resp.Schema = schema.Schema{
		// This description is used by the documentation generator and the language server.
		MarkdownDescription: "",
		Attributes: map[string]schema.Attribute{
			"type": schema.StringAttribute{
				MarkdownDescription: `The panel plugin type id. This is used to find the plugin to display the panel. Defaults to "heatmap".`,
				Computed:            true,
				Optional:            true,
				Required:            false,
			},
			"plugin_version": schema.StringAttribute{
				MarkdownDescription: `The version of the plugin that is used for this panel. This is used to find the plugin to display the panel and to migrate old panel configs.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"tags": schema.ListAttribute{
				MarkdownDescription: `Tags for the panel.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
				ElementType:         types.StringType,
			},
			"targets": schema.ListAttribute{
				MarkdownDescription: `Depends on the panel plugin. See the plugin documentation for details.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
				ElementType:         types.StringType,
			},
			"title": schema.StringAttribute{
				MarkdownDescription: `Panel title.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"description": schema.StringAttribute{
				MarkdownDescription: `Panel description.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"transparent": schema.BoolAttribute{
				MarkdownDescription: `Whether to display the panel without a background. Defaults to false.`,
				Computed:            true,
				Optional:            true,
				Required:            false,
			},
			"datasource": schema.SingleNestedAttribute{
				MarkdownDescription: `The datasource used in all targets.`,
				Computed:            true,
				Optional:            true,
				Required:            false,
				Attributes: map[string]schema.Attribute{
					"type": schema.StringAttribute{
						MarkdownDescription: `The plugin type-id`,
						Computed:            false,
						Optional:            true,
						Required:            false,
					},
					"uid": schema.StringAttribute{
						MarkdownDescription: `Specific datasource instance`,
						Computed:            false,
						Optional:            true,
						Required:            false,
					},
				},
			},
			"grid_pos": schema.SingleNestedAttribute{
				MarkdownDescription: `Grid position.`,
				Computed:            true,
				Optional:            true,
				Required:            false,
				Attributes: map[string]schema.Attribute{
					"h": schema.Int64Attribute{
						MarkdownDescription: `Panel height. The height is the number of rows from the top edge of the panel. Defaults to 9.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"w": schema.Int64Attribute{
						MarkdownDescription: `Panel width. The width is the number of columns from the left edge of the panel. Defaults to 12.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"x": schema.Int64Attribute{
						MarkdownDescription: `Panel x. The x coordinate is the number of columns from the left edge of the grid. Defaults to 0.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"y": schema.Int64Attribute{
						MarkdownDescription: `Panel y. The y coordinate is the number of rows from the top edge of the grid. Defaults to 0.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"static": schema.BoolAttribute{
						MarkdownDescription: `Whether the panel is fixed within the grid. If true, the panel will not be affected by other panels' interactions`,
						Computed:            false,
						Optional:            true,
						Required:            false,
					},
				},
			},
			"links": schema.ListNestedAttribute{
				MarkdownDescription: `Panel links.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
				NestedObject: schema.NestedAttributeObject{
					Attributes: map[string]schema.Attribute{
						"title": schema.StringAttribute{
							MarkdownDescription: `Title to display with the link`,
							Computed:            false,
							Optional:            false,
							Required:            true,
						},
						"type": schema.StringAttribute{
							MarkdownDescription: `Link type. Accepted values are dashboards (to refer to another dashboard) and link (to refer to an external resource)`,
							Computed:            false,
							Optional:            false,
							Required:            true,
						},
						"icon": schema.StringAttribute{
							MarkdownDescription: `Icon name to be displayed with the link`,
							Computed:            false,
							Optional:            false,
							Required:            true,
						},
						"tooltip": schema.StringAttribute{
							MarkdownDescription: `Tooltip to display when the user hovers their mouse over it`,
							Computed:            false,
							Optional:            false,
							Required:            true,
						},
						"url": schema.StringAttribute{
							MarkdownDescription: `Link URL. Only required/valid if the type is link`,
							Computed:            false,
							Optional:            false,
							Required:            true,
						},
						"tags": schema.ListAttribute{
							MarkdownDescription: `List of tags to limit the linked dashboards. If empty, all dashboards will be displayed. Only valid if the type is dashboards`,
							Computed:            false,
							Optional:            true,
							Required:            false,
							ElementType:         types.StringType,
						},
						"as_dropdown": schema.BoolAttribute{
							MarkdownDescription: `If true, all dashboards links will be displayed in a dropdown. If false, all dashboards links will be displayed side by side. Only valid if the type is dashboards. Defaults to false.`,
							Computed:            true,
							Optional:            true,
							Required:            false,
						},
						"target_blank": schema.BoolAttribute{
							MarkdownDescription: `If true, the link will be opened in a new tab. Defaults to false.`,
							Computed:            true,
							Optional:            true,
							Required:            false,
						},
						"include_vars": schema.BoolAttribute{
							MarkdownDescription: `If true, includes current template variables values in the link as query params. Defaults to false.`,
							Computed:            true,
							Optional:            true,
							Required:            false,
						},
						"keep_time": schema.BoolAttribute{
							MarkdownDescription: `If true, includes current time range in the link as query params. Defaults to false.`,
							Computed:            true,
							Optional:            true,
							Required:            false,
						},
					},
				},
			},
			"repeat": schema.StringAttribute{
				MarkdownDescription: `Name of template variable to repeat for.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"repeat_direction": schema.StringAttribute{
				MarkdownDescription: `Direction to repeat in if 'repeat' is set.
h for horizontal, v for vertical. Defaults to "h".`,
				Computed: true,
				Optional: true,
				Required: false,
			},
			"repeat_panel_id": schema.Int64Attribute{
				MarkdownDescription: `Id of the repeating panel.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"max_data_points": schema.Float64Attribute{
				MarkdownDescription: `The maximum number of data points that the panel queries are retrieving.`,
				Computed:            false,
				Optional:            true,
				Required:            false,
			},
			"transformations": schema.ListNestedAttribute{
				MarkdownDescription: `List of transformations that are applied to the panel data before rendering.
When there are multiple transformations, Grafana applies them in the order they are listed.
Each transformation creates a result set that then passes on to the next transformation in the processing pipeline.`,
				Computed: false,
				Optional: true,
				Required: false,
				NestedObject: schema.NestedAttributeObject{
					Attributes: map[string]schema.Attribute{
						"disabled": schema.BoolAttribute{
							MarkdownDescription: `Disabled transformations are skipped`,
							Computed:            false,
							Optional:            true,
							Required:            false,
						},
						"filter": schema.SingleNestedAttribute{
							MarkdownDescription: `Optional frame matcher. When missing it will be applied to all results`,
							Computed:            true,
							Optional:            true,
							Required:            false,
						},
					},
				},
			},
			"interval": schema.StringAttribute{
				MarkdownDescription: `The min time interval setting defines a lower limit for the $__interval and $__interval_ms variables.
This value must be formatted as a number followed by a valid time
identifier like: "40s", "3d", etc.
See: https://grafana.com/docs/grafana/latest/panels-visualizations/query-transform-data/#query-options`,
				Computed: false,
				Optional: true,
				Required: false,
			},
			"time_from": schema.StringAttribute{
				MarkdownDescription: `Overrides the relative time range for individual panels,
which causes them to be different than what is selected in
the dashboard time picker in the top-right corner of the dashboard. You can use this to show metrics from different
time periods or days on the same dashboard.
The value is formatted as time operation like: now-5m (Last 5 minutes), now/d (the day so far),
now-5d/d(Last 5 days), now/w (This week so far), now-2y/y (Last 2 years).
Note: Panel time overrides have no effect when the dashboard’s time range is absolute.
See: https://grafana.com/docs/grafana/latest/panels-visualizations/query-transform-data/#query-options`,
				Computed: false,
				Optional: true,
				Required: false,
			},
			"time_shift": schema.StringAttribute{
				MarkdownDescription: `Overrides the time range for individual panels by shifting its start and end relative to the time picker.
For example, you can shift the time range for the panel to be two hours earlier than the dashboard time picker setting 2h.
Note: Panel time overrides have no effect when the dashboard’s time range is absolute.
See: https://grafana.com/docs/grafana/latest/panels-visualizations/query-transform-data/#query-options`,
				Computed: false,
				Optional: true,
				Required: false,
			},
			"library_panel": schema.SingleNestedAttribute{
				MarkdownDescription: `Dynamically load the panel`,
				Computed:            true,
				Optional:            true,
				Required:            false,
				Attributes: map[string]schema.Attribute{
					"name": schema.StringAttribute{
						MarkdownDescription: `Library panel name`,
						Computed:            false,
						Optional:            false,
						Required:            true,
					},
					"uid": schema.StringAttribute{
						MarkdownDescription: `Library panel uid`,
						Computed:            false,
						Optional:            false,
						Required:            true,
					},
				},
			},
			"options": schema.SingleNestedAttribute{
				MarkdownDescription: ``,
				Computed:            true,
				Optional:            true,
				Required:            false,
				Attributes: map[string]schema.Attribute{
					"calculate": schema.BoolAttribute{
						MarkdownDescription: `Controls if the heatmap should be calculated from data. Defaults to false.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"calculation": schema.SingleNestedAttribute{
						MarkdownDescription: `Calculation options for the heatmap`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"x_buckets": schema.SingleNestedAttribute{
								MarkdownDescription: `The number of buckets to use for the xAxis in the heatmap`,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"mode": schema.StringAttribute{
										MarkdownDescription: `Sets the bucket calculation mode`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"value": schema.StringAttribute{
										MarkdownDescription: `The number of buckets to use for the axis in the heatmap`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"scale": schema.SingleNestedAttribute{
										MarkdownDescription: `Controls the scale of the buckets`,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"type": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
											"log": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
											"linear_threshold": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
										},
									},
								},
							},
							"y_buckets": schema.SingleNestedAttribute{
								MarkdownDescription: `The number of buckets to use for the yAxis in the heatmap`,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"mode": schema.StringAttribute{
										MarkdownDescription: `Sets the bucket calculation mode`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"value": schema.StringAttribute{
										MarkdownDescription: `The number of buckets to use for the axis in the heatmap`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"scale": schema.SingleNestedAttribute{
										MarkdownDescription: `Controls the scale of the buckets`,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"type": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
											"log": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
											"linear_threshold": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
										},
									},
								},
							},
						},
					},
					"color": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls the color options`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"heatmap_color_options": schema.SingleNestedAttribute{
								MarkdownDescription: ``,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"mode": schema.StringAttribute{
										MarkdownDescription: `Sets the color mode`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"scheme": schema.StringAttribute{
										MarkdownDescription: `Controls the color scheme used`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"fill": schema.StringAttribute{
										MarkdownDescription: `Controls the color fill when in opacity mode`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"scale": schema.StringAttribute{
										MarkdownDescription: `Controls the color scale`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"exponent": schema.Float64Attribute{
										MarkdownDescription: `Controls the exponent when scale is set to exponential`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"steps": schema.Int64Attribute{
										MarkdownDescription: `Controls the number of color steps`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"reverse": schema.BoolAttribute{
										MarkdownDescription: `Reverses the color scheme`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"min": schema.Float64Attribute{
										MarkdownDescription: `Sets the minimum value for the color scale`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"max": schema.Float64Attribute{
										MarkdownDescription: `Sets the maximum value for the color scale`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
						},
					},
					"filter_values": schema.SingleNestedAttribute{
						MarkdownDescription: `Filters values between a given range`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"filter_value_range": schema.SingleNestedAttribute{
								MarkdownDescription: ``,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"le": schema.Float64Attribute{
										MarkdownDescription: `Sets the filter range to values less than or equal to the given value`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"ge": schema.Float64Attribute{
										MarkdownDescription: `Sets the filter range to values greater than or equal to the given value`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
						},
					},
					"rows_frame": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls tick alignment and value name when not calculating from data`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"value": schema.StringAttribute{
								MarkdownDescription: `Sets the name of the cell when not calculating from data`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"layout": schema.StringAttribute{
								MarkdownDescription: `Controls tick alignment when not calculating from data`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
						},
					},
					"show_value": schema.StringAttribute{
						MarkdownDescription: `| *{
	layout: ui.HeatmapCellLayout & "auto" // TODO: fix after remove when https://github.com/grafana/cuetsy/issues/74 is fixed
}
Controls the display of the value in the cell. Defaults to "auto".`,
						Computed: true,
						Optional: true,
						Required: false,
					},
					"cell_gap": schema.Int64Attribute{
						MarkdownDescription: `Controls gap between cells. Defaults to 1.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"cell_radius": schema.Float64Attribute{
						MarkdownDescription: `Controls cell radius`,
						Computed:            false,
						Optional:            true,
						Required:            false,
					},
					"cell_values": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls cell value unit`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"cell_values": schema.SingleNestedAttribute{
								MarkdownDescription: ``,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"unit": schema.StringAttribute{
										MarkdownDescription: `Controls the cell value unit`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"decimals": schema.Float64Attribute{
										MarkdownDescription: `Controls the number of decimals for cell values`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
						},
					},
					"y_axis": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls yAxis placement`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"unit": schema.StringAttribute{
								MarkdownDescription: `Sets the yAxis unit`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"reverse": schema.BoolAttribute{
								MarkdownDescription: `Reverses the yAxis`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"decimals": schema.Float64Attribute{
								MarkdownDescription: `Controls the number of decimals for yAxis values`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"min": schema.Float64Attribute{
								MarkdownDescription: `Sets the minimum value for the yAxis`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_placement": schema.StringAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_color_mode": schema.StringAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_label": schema.StringAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_width": schema.Float64Attribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_soft_min": schema.Float64Attribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_soft_max": schema.Float64Attribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_grid_show": schema.BoolAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"scale_distribution": schema.SingleNestedAttribute{
								MarkdownDescription: ``,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"type": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"log": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"linear_threshold": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
							"max": schema.Float64Attribute{
								MarkdownDescription: `Sets the maximum value for the yAxis`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"axis_centered_zero": schema.BoolAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
						},
					},
					"legend": schema.SingleNestedAttribute{
						MarkdownDescription: `| *{
	axisPlacement: ui.AxisPlacement & "left" // TODO: fix after remove when https://github.com/grafana/cuetsy/issues/74 is fixed
}
Controls legend options`,
						Computed: true,
						Optional: true,
						Required: false,
						Attributes: map[string]schema.Attribute{
							"show": schema.BoolAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            false,
								Required:            true,
							},
						},
					},
					"tooltip": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls tooltip options`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"show": schema.BoolAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            false,
								Required:            true,
							},
							"y_histogram": schema.BoolAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            false,
								Required:            true,
							},
						},
					},
					"exemplars": schema.SingleNestedAttribute{
						MarkdownDescription: `Controls exemplar options`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"color": schema.StringAttribute{
								MarkdownDescription: ``,
								Computed:            false,
								Optional:            false,
								Required:            true,
							},
						},
					},
				},
			},
			"field_config": schema.SingleNestedAttribute{
				MarkdownDescription: `Field options allow you to change how the data is displayed in your visualizations.`,
				Computed:            true,
				Optional:            true,
				Required:            false,
				Attributes: map[string]schema.Attribute{
					"defaults": schema.SingleNestedAttribute{
						MarkdownDescription: `Defaults are the options applied to all fields.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"display_name": schema.StringAttribute{
								MarkdownDescription: `The display value for this field.  This supports template variables blank is auto`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"display_name_from_ds": schema.StringAttribute{
								MarkdownDescription: `This can be used by data sources that return and explicit naming structure for values and labels
When this property is configured, this value is used rather than the default naming strategy.`,
								Computed: false,
								Optional: true,
								Required: false,
							},
							"description": schema.StringAttribute{
								MarkdownDescription: `Human readable field metadata`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"path": schema.StringAttribute{
								MarkdownDescription: `An explicit path to the field in the datasource.  When the frame meta includes a path,
This will default to ${frame.meta.path}/${field.name}

When defined, this value can be used as an identifier within the datasource scope, and
may be used to update the results`,
								Computed: false,
								Optional: true,
								Required: false,
							},
							"writeable": schema.BoolAttribute{
								MarkdownDescription: `True if data source can write a value to the path. Auth/authz are supported separately`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"filterable": schema.BoolAttribute{
								MarkdownDescription: `True if data source field supports ad-hoc filters`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"unit": schema.StringAttribute{
								MarkdownDescription: `Unit a field should use. The unit you select is applied to all fields except time.
You can use the units ID availables in Grafana or a custom unit.
Available units in Grafana: https://github.com/grafana/grafana/blob/main/packages/grafana-data/src/valueFormats/categories.ts
As custom unit, you can use the following formats:
suffix:<suffix> for custom unit that should go after value.
prefix:<prefix> for custom unit that should go before value.
time:<format> For custom date time formats type for example time:YYYY-MM-DD.
si:<base scale><unit characters> for custom SI units. For example: si: mF. This one is a bit more advanced as you can specify both a unit and the source data scale. So if your source data is represented as milli (thousands of) something prefix the unit with that SI scale character.
count:<unit> for a custom count unit.
currency:<unit> for custom a currency unit.`,
								Computed: false,
								Optional: true,
								Required: false,
							},
							"decimals": schema.Float64Attribute{
								MarkdownDescription: `Specify the number of decimals Grafana includes in the rendered value.
If you leave this field blank, Grafana automatically truncates the number of decimals based on the value.
For example 1.1234 will display as 1.12 and 100.456 will display as 100.
To display all decimals, set the unit to String.`,
								Computed: false,
								Optional: true,
								Required: false,
							},
							"min": schema.Float64Attribute{
								MarkdownDescription: `The minimum value used in percentage threshold calculations. Leave blank for auto calculation based on all series and fields.`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"max": schema.Float64Attribute{
								MarkdownDescription: `The maximum value used in percentage threshold calculations. Leave blank for auto calculation based on all series and fields.`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"mappings": schema.ListNestedAttribute{
								MarkdownDescription: `Convert input values into a display string`,
								Computed:            false,
								Optional:            true,
								Required:            false,
								NestedObject: schema.NestedAttributeObject{
									Attributes: map[string]schema.Attribute{
										"value_map": schema.SingleNestedAttribute{
											MarkdownDescription: ``,
											Computed:            true,
											Optional:            true,
											Required:            false,
											Attributes: map[string]schema.Attribute{
												"type": schema.StringAttribute{
													MarkdownDescription: ``,
													Computed:            false,
													Optional:            false,
													Required:            true,
												},
												"options": schema.MapNestedAttribute{
													MarkdownDescription: `Map with <value_to_match>: ValueMappingResult. For example: { "10": { text: "Perfection!", color: "green" } }`,
													Computed:            false,
													Optional:            true,
													Required:            false,
													NestedObject: schema.NestedAttributeObject{
														Attributes: map[string]schema.Attribute{
															"text": schema.StringAttribute{
																MarkdownDescription: `Text to display when the value matches`,
																Computed:            false,
																Optional:            true,
																Required:            false,
															},
															"color": schema.StringAttribute{
																MarkdownDescription: `Text to use when the value matches`,
																Computed:            false,
																Optional:            true,
																Required:            false,
															},
															"icon": schema.StringAttribute{
																MarkdownDescription: `Icon to display when the value matches. Only specific visualizations.`,
																Computed:            false,
																Optional:            true,
																Required:            false,
															},
															"index": schema.Int64Attribute{
																MarkdownDescription: `Position in the mapping array. Only used internally.`,
																Computed:            false,
																Optional:            true,
																Required:            false,
															},
														},
													},
												},
											},
										},
										"range_map": schema.SingleNestedAttribute{
											MarkdownDescription: ``,
											Computed:            true,
											Optional:            true,
											Required:            false,
											Attributes: map[string]schema.Attribute{
												"type": schema.StringAttribute{
													MarkdownDescription: ``,
													Computed:            false,
													Optional:            false,
													Required:            true,
												},
												"options": schema.SingleNestedAttribute{
													MarkdownDescription: `Range to match against and the result to apply when the value is within the range`,
													Computed:            true,
													Optional:            true,
													Required:            false,
													Attributes: map[string]schema.Attribute{
														"from": schema.StringAttribute{
															MarkdownDescription: `Min value of the range. It can be null which means -Infinity`,
															Computed:            false,
															Optional:            false,
															Required:            true,
														},
														"to": schema.StringAttribute{
															MarkdownDescription: `Max value of the range. It can be null which means +Infinity`,
															Computed:            false,
															Optional:            false,
															Required:            true,
														},
														"result": schema.SingleNestedAttribute{
															MarkdownDescription: `Config to apply when the value is within the range`,
															Computed:            true,
															Optional:            true,
															Required:            false,
															Attributes: map[string]schema.Attribute{
																"text": schema.StringAttribute{
																	MarkdownDescription: `Text to display when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"color": schema.StringAttribute{
																	MarkdownDescription: `Text to use when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"icon": schema.StringAttribute{
																	MarkdownDescription: `Icon to display when the value matches. Only specific visualizations.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"index": schema.Int64Attribute{
																	MarkdownDescription: `Position in the mapping array. Only used internally.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
															},
														},
													},
												},
											},
										},
										"regex_map": schema.SingleNestedAttribute{
											MarkdownDescription: ``,
											Computed:            true,
											Optional:            true,
											Required:            false,
											Attributes: map[string]schema.Attribute{
												"type": schema.StringAttribute{
													MarkdownDescription: ``,
													Computed:            false,
													Optional:            false,
													Required:            true,
												},
												"options": schema.SingleNestedAttribute{
													MarkdownDescription: `Regular expression to match against and the result to apply when the value matches the regex`,
													Computed:            true,
													Optional:            true,
													Required:            false,
													Attributes: map[string]schema.Attribute{
														"pattern": schema.StringAttribute{
															MarkdownDescription: `Regular expression to match against`,
															Computed:            false,
															Optional:            false,
															Required:            true,
														},
														"result": schema.SingleNestedAttribute{
															MarkdownDescription: `Config to apply when the value matches the regex`,
															Computed:            true,
															Optional:            true,
															Required:            false,
															Attributes: map[string]schema.Attribute{
																"text": schema.StringAttribute{
																	MarkdownDescription: `Text to display when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"color": schema.StringAttribute{
																	MarkdownDescription: `Text to use when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"icon": schema.StringAttribute{
																	MarkdownDescription: `Icon to display when the value matches. Only specific visualizations.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"index": schema.Int64Attribute{
																	MarkdownDescription: `Position in the mapping array. Only used internally.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
															},
														},
													},
												},
											},
										},
										"special_value_map": schema.SingleNestedAttribute{
											MarkdownDescription: ``,
											Computed:            true,
											Optional:            true,
											Required:            false,
											Attributes: map[string]schema.Attribute{
												"type": schema.StringAttribute{
													MarkdownDescription: ``,
													Computed:            false,
													Optional:            false,
													Required:            true,
												},
												"options": schema.SingleNestedAttribute{
													MarkdownDescription: ``,
													Computed:            true,
													Optional:            true,
													Required:            false,
													Attributes: map[string]schema.Attribute{
														"match": schema.StringAttribute{
															MarkdownDescription: `Special value to match against`,
															Computed:            false,
															Optional:            false,
															Required:            true,
														},
														"result": schema.SingleNestedAttribute{
															MarkdownDescription: `Config to apply when the value matches the special value`,
															Computed:            true,
															Optional:            true,
															Required:            false,
															Attributes: map[string]schema.Attribute{
																"text": schema.StringAttribute{
																	MarkdownDescription: `Text to display when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"color": schema.StringAttribute{
																	MarkdownDescription: `Text to use when the value matches`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"icon": schema.StringAttribute{
																	MarkdownDescription: `Icon to display when the value matches. Only specific visualizations.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
																"index": schema.Int64Attribute{
																	MarkdownDescription: `Position in the mapping array. Only used internally.`,
																	Computed:            false,
																	Optional:            true,
																	Required:            false,
																},
															},
														},
													},
												},
											},
										},
									},
								},
							},
							"thresholds": schema.SingleNestedAttribute{
								MarkdownDescription: `Map numeric values to states`,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"mode": schema.StringAttribute{
										MarkdownDescription: `Thresholds mode.`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"steps": schema.ListNestedAttribute{
										MarkdownDescription: `Must be sorted by 'value', first value is always -Infinity`,
										Computed:            false,
										Optional:            true,
										Required:            false,
										NestedObject: schema.NestedAttributeObject{
											Attributes: map[string]schema.Attribute{
												"value": schema.StringAttribute{
													MarkdownDescription: `Value represents a specified metric for the threshold, which triggers a visual change in the dashboard when this value is met or exceeded.
Nulls currently appear here when serializing -Infinity to JSON.`,
													Computed: false,
													Optional: false,
													Required: true,
												},
												"color": schema.StringAttribute{
													MarkdownDescription: `Color represents the color of the visual change that will occur in the dashboard when the threshold value is met or exceeded.`,
													Computed:            false,
													Optional:            false,
													Required:            true,
												},
											},
										},
									},
								},
							},
							"color": schema.SingleNestedAttribute{
								MarkdownDescription: `Panel color configuration`,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"mode": schema.StringAttribute{
										MarkdownDescription: `The main color scheme mode.`,
										Computed:            false,
										Optional:            false,
										Required:            true,
									},
									"fixed_color": schema.StringAttribute{
										MarkdownDescription: `The fixed color value for fixed or shades color modes.`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"series_by": schema.StringAttribute{
										MarkdownDescription: `Some visualizations need to know how to assign a series color from by value color schemes.`,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
							"no_value": schema.StringAttribute{
								MarkdownDescription: `Alternative to empty string`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"custom": schema.SingleNestedAttribute{
								MarkdownDescription: ``,
								Computed:            true,
								Optional:            true,
								Required:            false,
								Attributes: map[string]schema.Attribute{
									"scale_distribution": schema.SingleNestedAttribute{
										MarkdownDescription: ``,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"type": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
											"log": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
											"linear_threshold": schema.Float64Attribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
										},
									},
									"hide_from": schema.SingleNestedAttribute{
										MarkdownDescription: ``,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"tooltip": schema.BoolAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
											"legend": schema.BoolAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
											"viz": schema.BoolAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
										},
									},
								},
							},
						},
					},
					"overrides": schema.ListNestedAttribute{
						MarkdownDescription: `Overrides are the options applied to specific fields overriding the defaults.`,
						Computed:            false,
						Optional:            true,
						Required:            false,
						NestedObject: schema.NestedAttributeObject{
							Attributes: map[string]schema.Attribute{
								"matcher": schema.SingleNestedAttribute{
									MarkdownDescription: ``,
									Computed:            true,
									Optional:            true,
									Required:            false,
								},
								"properties": schema.ListNestedAttribute{
									MarkdownDescription: ``,
									Computed:            false,
									Optional:            true,
									Required:            false,
								},
							},
						},
					},
				},
			},

			"rendered_json": schema.StringAttribute{
				Computed:            true,
				MarkdownDescription: "This datasource rendered as JSON",
			},
		},
	}
}

func (d *PanelHeatmapDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
}

func (d *PanelHeatmapDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) {
	var data PanelHeatmapDataSourceModel

	// Read Terraform configuration data into the model
	resp.Diagnostics.Append(req.Config.Get(ctx, &data)...)

	if resp.Diagnostics.HasError() {
		return
	}

	JSONConfig, err := json.Marshal(data)
	if err != nil {
		resp.Diagnostics.AddError("JSON marshalling error", err.Error())
		return
	}

	// fix up the targets Attribute
	// Read into a map[string]interface{} and then marshal it back to JSON
	// This is a workaround for the fact that the targets attribute should be a list of maps but is a list of json strings
	dataMap := make(map[string]interface{})
	err = json.Unmarshal(JSONConfig, &dataMap)
	if err != nil {
		resp.Diagnostics.AddError("error unmarshalling config into Go map", err.Error())
		return
	}
	targets := data.Targets.Elements()
	targetsMaps := make([]map[string]interface{}, len(targets))
	for i, target := range targets {
		targetMap := make(map[string]interface{})
		err = json.Unmarshal([]byte(target.(types.String).ValueString()), &targetMap)
		if err != nil {
			resp.Diagnostics.AddError("error unmarshalling target into go map", err.Error())
			return
		}
		targetsMaps[i] = targetMap
	}

	dataMap["targets"] = targetsMaps
	JSONConfig, err = json.MarshalIndent(dataMap, "", "  ")
	if err != nil {
		resp.Diagnostics.AddError("error marshalling go map into json", err.Error())
		return
	}

	// Not sure about that
	data.RenderedJSON = types.StringValue(string(JSONConfig))

	// Write logs using the tflog package
	// Documentation: https://terraform.io/plugin/log
	tflog.Trace(ctx, "read a data source")

	// Save data into Terraform state
	resp.Diagnostics.Append(resp.State.Set(ctx, &data)...)
}