datasource_panel_gauge_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              = &PanelGaugeDataSource{}
	_ datasource.DataSourceWithConfigure = &PanelGaugeDataSource{}
)

func NewPanelGaugeDataSource() datasource.DataSource {
	return &PanelGaugeDataSource{}
}

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

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

func (m PanelGaugeDataSourceModel_Datasource) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_Datasource{
		Type: attr_type,
		Uid:  attr_uid,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_Datasource) ApplyDefaults() PanelGaugeDataSourceModel_Datasource {

	return m
}

type PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_GridPos) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_GridPos{
		H:      attr_h,
		W:      attr_w,
		X:      attr_x,
		Y:      attr_y,
		Static: attr_static,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_GridPos) ApplyDefaults() PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_Links) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_Links) ApplyDefaults() PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_Transformations_Filter struct {
}

func (m PanelGaugeDataSourceModel_Transformations_Filter) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_Transformations_Filter struct {
	}

	m = m.ApplyDefaults()

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

func (m PanelGaugeDataSourceModel_Transformations_Filter) ApplyDefaults() PanelGaugeDataSourceModel_Transformations_Filter {

	return m
}

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

func (m PanelGaugeDataSourceModel_Transformations) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_Transformations{
		Disabled: attr_disabled,
		Filter:   attr_filter,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_Transformations) ApplyDefaults() PanelGaugeDataSourceModel_Transformations {

	return m
}

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

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

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

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

func (m PanelGaugeDataSourceModel_LibraryPanel) ApplyDefaults() PanelGaugeDataSourceModel_LibraryPanel {

	return m
}

type PanelGaugeDataSourceModel_Options_ReduceOptions struct {
	Values types.Bool    `tfsdk:"values"`
	Limit  types.Float64 `tfsdk:"limit"`
	Calcs  types.List    `tfsdk:"calcs"`
	Fields types.String  `tfsdk:"fields"`
}

func (m PanelGaugeDataSourceModel_Options_ReduceOptions) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_Options_ReduceOptions struct {
		Values *bool    `json:"values,omitempty"`
		Limit  *float64 `json:"limit,omitempty"`
		Calcs  []string `json:"calcs,omitempty"`
		Fields *string  `json:"fields,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_values := m.Values.ValueBoolPointer()
	attr_limit := m.Limit.ValueFloat64Pointer()
	attr_calcs := []string{}
	for _, v := range m.Calcs.Elements() {
		attr_calcs = append(attr_calcs, v.(types.String).ValueString())
	}
	attr_fields := m.Fields.ValueStringPointer()

	model := &jsonPanelGaugeDataSourceModel_Options_ReduceOptions{
		Values: attr_values,
		Limit:  attr_limit,
		Calcs:  attr_calcs,
		Fields: attr_fields,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_Options_ReduceOptions) ApplyDefaults() PanelGaugeDataSourceModel_Options_ReduceOptions {
	if len(m.Calcs.Elements()) == 0 {
		m.Calcs, _ = types.ListValue(types.StringType, []attr.Value{})
	}
	return m
}

type PanelGaugeDataSourceModel_Options_Text struct {
	TitleSize types.Float64 `tfsdk:"title_size"`
	ValueSize types.Float64 `tfsdk:"value_size"`
}

func (m PanelGaugeDataSourceModel_Options_Text) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_Options_Text struct {
		TitleSize *float64 `json:"titleSize,omitempty"`
		ValueSize *float64 `json:"valueSize,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_titlesize := m.TitleSize.ValueFloat64Pointer()
	attr_valuesize := m.ValueSize.ValueFloat64Pointer()

	model := &jsonPanelGaugeDataSourceModel_Options_Text{
		TitleSize: attr_titlesize,
		ValueSize: attr_valuesize,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_Options_Text) ApplyDefaults() PanelGaugeDataSourceModel_Options_Text {

	return m
}

type PanelGaugeDataSourceModel_Options struct {
	ShowThresholdLabels  types.Bool                                       `tfsdk:"show_threshold_labels"`
	ReduceOptions        *PanelGaugeDataSourceModel_Options_ReduceOptions `tfsdk:"reduce_options"`
	Text                 *PanelGaugeDataSourceModel_Options_Text          `tfsdk:"text"`
	ShowThresholdMarkers types.Bool                                       `tfsdk:"show_threshold_markers"`
	Orientation          types.String                                     `tfsdk:"orientation"`
}

func (m PanelGaugeDataSourceModel_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_Options struct {
		ShowThresholdLabels  bool        `json:"showThresholdLabels"`
		ReduceOptions        interface{} `json:"reduceOptions,omitempty"`
		Text                 interface{} `json:"text,omitempty"`
		ShowThresholdMarkers bool        `json:"showThresholdMarkers"`
		Orientation          string      `json:"orientation"`
	}

	m = m.ApplyDefaults()
	attr_showthresholdlabels := m.ShowThresholdLabels.ValueBool()
	var attr_reduceoptions interface{}
	if m.ReduceOptions != nil {
		attr_reduceoptions = m.ReduceOptions
	}
	var attr_text interface{}
	if m.Text != nil {
		attr_text = m.Text
	}
	attr_showthresholdmarkers := m.ShowThresholdMarkers.ValueBool()
	attr_orientation := m.Orientation.ValueString()

	model := &jsonPanelGaugeDataSourceModel_Options{
		ShowThresholdLabels:  attr_showthresholdlabels,
		ReduceOptions:        attr_reduceoptions,
		Text:                 attr_text,
		ShowThresholdMarkers: attr_showthresholdmarkers,
		Orientation:          attr_orientation,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_Options) ApplyDefaults() PanelGaugeDataSourceModel_Options {
	if m.ShowThresholdLabels.IsNull() {
		m.ShowThresholdLabels = types.BoolValue(false)
	}
	if m.ShowThresholdMarkers.IsNull() {
		m.ShowThresholdMarkers = types.BoolValue(true)
	}
	return m
}

type PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap_Options {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap {

	return m
}

type PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options_Result {

	return m
}

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

func (m PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options{
		From:   attr_from,
		To:     attr_to,
		Result: attr_result,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap struct {
	Type    types.String                                                              `tfsdk:"type"`
	Options *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap_Options `tfsdk:"options"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap {

	return m
}

type PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options_Result {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options{
		Pattern: attr_pattern,
		Result:  attr_result,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap struct {
	Type    types.String                                                              `tfsdk:"type"`
	Options *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap_Options `tfsdk:"options"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap {

	return m
}

type PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result{
		Text:  attr_text,
		Color: attr_color,
		Icon:  attr_icon,
		Index: attr_index,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options_Result {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options{
		Match:  attr_match,
		Result: attr_result,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap struct {
	Type    types.String                                                                     `tfsdk:"type"`
	Options *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap_Options `tfsdk:"options"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap{
		Type:    attr_type,
		Options: attr_options,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings struct {
	ValueMap        *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_ValueMap        `tfsdk:"value_map"`
	RangeMap        *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RangeMap        `tfsdk:"range_map"`
	RegexMap        *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_RegexMap        `tfsdk:"regex_map"`
	SpecialValueMap *PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings_SpecialValueMap `tfsdk:"special_value_map"`
}

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

	return json.Marshal(json_PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings {

	return m
}

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

func (m PanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds_Steps) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds_Steps{
		Value: attr_value,
		Color: attr_color,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds_Steps) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds_Steps {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds{
		Mode:  attr_mode,
		Steps: attr_steps,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Color) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Color{
		Mode:       attr_mode,
		FixedColor: attr_fixedcolor,
		SeriesBy:   attr_seriesby,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Color) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Color {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle struct {
	Mode types.String `tfsdk:"mode"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle struct {
		Mode string `json:"mode"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueString()

	model := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle{
		Mode: attr_mode,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle struct {
	Fill types.String `tfsdk:"fill"`
	Dash types.List   `tfsdk:"dash"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle struct {
		Fill *string   `json:"fill,omitempty"`
		Dash []float64 `json:"dash,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_fill := m.Fill.ValueStringPointer()
	attr_dash := []float64{}
	for _, v := range m.Dash.Elements() {
		attr_dash = append(attr_dash, v.(types.Float64).ValueFloat64())
	}

	model := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle{
		Fill: attr_fill,
		Dash: attr_dash,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle {
	if len(m.Dash.Elements()) == 0 {
		m.Dash, _ = types.ListValue(types.Float64Type, []attr.Value{})
	}
	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution{
		Type:            attr_type,
		Log:             attr_log,
		LinearThreshold: attr_linearthreshold,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking struct {
	Mode  types.String `tfsdk:"mode"`
	Group types.String `tfsdk:"group"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking struct {
		Mode  *string `json:"mode,omitempty"`
		Group *string `json:"group,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_mode := m.Mode.ValueStringPointer()
	attr_group := m.Group.ValueStringPointer()

	model := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking{
		Mode:  attr_mode,
		Group: attr_group,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking {

	return m
}

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

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_HideFrom) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_HideFrom{
		Tooltip: attr_tooltip,
		Legend:  attr_legend,
		Viz:     attr_viz,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_HideFrom) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_HideFrom {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom struct {
	DrawStyle         types.String                                                             `tfsdk:"draw_style"`
	GradientMode      types.String                                                             `tfsdk:"gradient_mode"`
	ThresholdsStyle   *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ThresholdsStyle   `tfsdk:"thresholds_style"`
	LineColor         types.String                                                             `tfsdk:"line_color"`
	LineWidth         types.Float64                                                            `tfsdk:"line_width"`
	LineInterpolation types.String                                                             `tfsdk:"line_interpolation"`
	LineStyle         *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_LineStyle         `tfsdk:"line_style"`
	FillColor         types.String                                                             `tfsdk:"fill_color"`
	FillOpacity       types.Float64                                                            `tfsdk:"fill_opacity"`
	ShowPoints        types.String                                                             `tfsdk:"show_points"`
	PointSize         types.Float64                                                            `tfsdk:"point_size"`
	PointColor        types.String                                                             `tfsdk:"point_color"`
	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 *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_ScaleDistribution `tfsdk:"scale_distribution"`
	BarAlignment      types.Int64                                                              `tfsdk:"bar_alignment"`
	BarWidthFactor    types.Float64                                                            `tfsdk:"bar_width_factor"`
	Stacking          *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_Stacking          `tfsdk:"stacking"`
	HideFrom          *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom_HideFrom          `tfsdk:"hide_from"`
	Transform         types.String                                                             `tfsdk:"transform"`
	SpanNulls         types.String                                                             `tfsdk:"span_nulls"`
	FillBelowTo       types.String                                                             `tfsdk:"fill_below_to"`
	PointSymbol       types.String                                                             `tfsdk:"point_symbol"`
	AxisCenteredZero  types.Bool                                                               `tfsdk:"axis_centered_zero"`
	BarMaxWidth       types.Float64                                                            `tfsdk:"bar_max_width"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom) GetAttrSpanNulls() interface{} {
	var attr interface{}
	var err error

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

	return m.SpanNulls.ValueString()
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom struct {
		DrawStyle         *string     `json:"drawStyle,omitempty"`
		GradientMode      *string     `json:"gradientMode,omitempty"`
		ThresholdsStyle   interface{} `json:"thresholdsStyle,omitempty"`
		LineColor         *string     `json:"lineColor,omitempty"`
		LineWidth         *float64    `json:"lineWidth,omitempty"`
		LineInterpolation *string     `json:"lineInterpolation,omitempty"`
		LineStyle         interface{} `json:"lineStyle,omitempty"`
		FillColor         *string     `json:"fillColor,omitempty"`
		FillOpacity       *float64    `json:"fillOpacity,omitempty"`
		ShowPoints        *string     `json:"showPoints,omitempty"`
		PointSize         *float64    `json:"pointSize,omitempty"`
		PointColor        *string     `json:"pointColor,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"`
		BarAlignment      *int64      `json:"barAlignment,omitempty"`
		BarWidthFactor    *float64    `json:"barWidthFactor,omitempty"`
		Stacking          interface{} `json:"stacking,omitempty"`
		HideFrom          interface{} `json:"hideFrom,omitempty"`
		Transform         *string     `json:"transform,omitempty"`
		SpanNulls         interface{} `json:"spanNulls,omitempty"`
		FillBelowTo       *string     `json:"fillBelowTo,omitempty"`
		PointSymbol       *string     `json:"pointSymbol,omitempty"`
		AxisCenteredZero  *bool       `json:"axisCenteredZero,omitempty"`
		BarMaxWidth       *float64    `json:"barMaxWidth,omitempty"`
	}

	m = m.ApplyDefaults()
	attr_drawstyle := m.DrawStyle.ValueStringPointer()
	attr_gradientmode := m.GradientMode.ValueStringPointer()
	var attr_thresholdsstyle interface{}
	if m.ThresholdsStyle != nil {
		attr_thresholdsstyle = m.ThresholdsStyle
	}
	attr_linecolor := m.LineColor.ValueStringPointer()
	attr_linewidth := m.LineWidth.ValueFloat64Pointer()
	attr_lineinterpolation := m.LineInterpolation.ValueStringPointer()
	var attr_linestyle interface{}
	if m.LineStyle != nil {
		attr_linestyle = m.LineStyle
	}
	attr_fillcolor := m.FillColor.ValueStringPointer()
	attr_fillopacity := m.FillOpacity.ValueFloat64Pointer()
	attr_showpoints := m.ShowPoints.ValueStringPointer()
	attr_pointsize := m.PointSize.ValueFloat64Pointer()
	attr_pointcolor := m.PointColor.ValueStringPointer()
	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_baralignment := m.BarAlignment.ValueInt64Pointer()
	attr_barwidthfactor := m.BarWidthFactor.ValueFloat64Pointer()
	var attr_stacking interface{}
	if m.Stacking != nil {
		attr_stacking = m.Stacking
	}
	var attr_hidefrom interface{}
	if m.HideFrom != nil {
		attr_hidefrom = m.HideFrom
	}
	attr_transform := m.Transform.ValueStringPointer()
	attr_spannulls := m.GetAttrSpanNulls()
	attr_fillbelowto := m.FillBelowTo.ValueStringPointer()
	attr_pointsymbol := m.PointSymbol.ValueStringPointer()
	attr_axiscenteredzero := m.AxisCenteredZero.ValueBoolPointer()
	attr_barmaxwidth := m.BarMaxWidth.ValueFloat64Pointer()

	model := &jsonPanelGaugeDataSourceModel_FieldConfig_Defaults_Custom{
		DrawStyle:         attr_drawstyle,
		GradientMode:      attr_gradientmode,
		ThresholdsStyle:   attr_thresholdsstyle,
		LineColor:         attr_linecolor,
		LineWidth:         attr_linewidth,
		LineInterpolation: attr_lineinterpolation,
		LineStyle:         attr_linestyle,
		FillColor:         attr_fillcolor,
		FillOpacity:       attr_fillopacity,
		ShowPoints:        attr_showpoints,
		PointSize:         attr_pointsize,
		PointColor:        attr_pointcolor,
		AxisPlacement:     attr_axisplacement,
		AxisColorMode:     attr_axiscolormode,
		AxisLabel:         attr_axislabel,
		AxisWidth:         attr_axiswidth,
		AxisSoftMin:       attr_axissoftmin,
		AxisSoftMax:       attr_axissoftmax,
		AxisGridShow:      attr_axisgridshow,
		ScaleDistribution: attr_scaledistribution,
		BarAlignment:      attr_baralignment,
		BarWidthFactor:    attr_barwidthfactor,
		Stacking:          attr_stacking,
		HideFrom:          attr_hidefrom,
		Transform:         attr_transform,
		SpanNulls:         attr_spannulls,
		FillBelowTo:       attr_fillbelowto,
		PointSymbol:       attr_pointsymbol,
		AxisCenteredZero:  attr_axiscenteredzero,
		BarMaxWidth:       attr_barmaxwidth,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom {

	return m
}

type PanelGaugeDataSourceModel_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          []PanelGaugeDataSourceModel_FieldConfig_Defaults_Mappings  `tfsdk:"mappings"`
	Thresholds        *PanelGaugeDataSourceModel_FieldConfig_Defaults_Thresholds `tfsdk:"thresholds"`
	Color             *PanelGaugeDataSourceModel_FieldConfig_Defaults_Color      `tfsdk:"color"`
	NoValue           types.String                                               `tfsdk:"no_value"`
	Custom            *PanelGaugeDataSourceModel_FieldConfig_Defaults_Custom     `tfsdk:"custom"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Defaults) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_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 PanelGaugeDataSourceModel_FieldConfig_Defaults) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Defaults {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher struct {
}

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher struct {
	}

	m = m.ApplyDefaults()

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

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Overrides_Properties struct {
}

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides_Properties) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_FieldConfig_Overrides_Properties struct {
	}

	m = m.ApplyDefaults()

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

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides_Properties) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Overrides_Properties {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig_Overrides struct {
	Matcher    *PanelGaugeDataSourceModel_FieldConfig_Overrides_Matcher     `tfsdk:"matcher"`
	Properties []PanelGaugeDataSourceModel_FieldConfig_Overrides_Properties `tfsdk:"properties"`
}

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig_Overrides{
		Matcher:    attr_matcher,
		Properties: attr_properties,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig_Overrides) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig_Overrides {

	return m
}

type PanelGaugeDataSourceModel_FieldConfig struct {
	Defaults  *PanelGaugeDataSourceModel_FieldConfig_Defaults   `tfsdk:"defaults"`
	Overrides []PanelGaugeDataSourceModel_FieldConfig_Overrides `tfsdk:"overrides"`
}

func (m PanelGaugeDataSourceModel_FieldConfig) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel_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 := &jsonPanelGaugeDataSourceModel_FieldConfig{
		Defaults:  attr_defaults,
		Overrides: attr_overrides,
	}
	return json.Marshal(model)
}

func (m PanelGaugeDataSourceModel_FieldConfig) ApplyDefaults() PanelGaugeDataSourceModel_FieldConfig {

	return m
}

type PanelGaugeDataSourceModel 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      *PanelGaugeDataSourceModel_Datasource       `tfsdk:"datasource"`
	GridPos         *PanelGaugeDataSourceModel_GridPos          `tfsdk:"grid_pos"`
	Links           []PanelGaugeDataSourceModel_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 []PanelGaugeDataSourceModel_Transformations `tfsdk:"transformations"`
	Interval        types.String                                `tfsdk:"interval"`
	TimeFrom        types.String                                `tfsdk:"time_from"`
	TimeShift       types.String                                `tfsdk:"time_shift"`
	LibraryPanel    *PanelGaugeDataSourceModel_LibraryPanel     `tfsdk:"library_panel"`
	Options         *PanelGaugeDataSourceModel_Options          `tfsdk:"options"`
	FieldConfig     *PanelGaugeDataSourceModel_FieldConfig      `tfsdk:"field_config"`
}

func (m PanelGaugeDataSourceModel) MarshalJSON() ([]byte, error) {
	type jsonPanelGaugeDataSourceModel 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 := &jsonPanelGaugeDataSourceModel{
		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 PanelGaugeDataSourceModel) ApplyDefaults() PanelGaugeDataSourceModel {
	if m.Type.IsNull() {
		m.Type = types.StringValue(`gauge`)
	}
	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 *PanelGaugeDataSource) Metadata(ctx context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
	resp.TypeName = req.ProviderTypeName + "_panel_gauge"
}

func (d *PanelGaugeDataSource) 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 "gauge".`,
				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{
					"show_threshold_labels": schema.BoolAttribute{
						MarkdownDescription: ` Defaults to false.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"reduce_options": schema.SingleNestedAttribute{
						MarkdownDescription: ``,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"values": schema.BoolAttribute{
								MarkdownDescription: `If true show each row value`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"limit": schema.Float64Attribute{
								MarkdownDescription: `if showing all values limit`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"calcs": schema.ListAttribute{
								MarkdownDescription: `When !values, pick one value for the whole field`,
								Computed:            false,
								Optional:            true,
								Required:            false,
								ElementType:         types.StringType,
							},
							"fields": schema.StringAttribute{
								MarkdownDescription: `Which fields to show.  By default this is only numeric fields`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
						},
					},
					"text": schema.SingleNestedAttribute{
						MarkdownDescription: ``,
						Computed:            true,
						Optional:            true,
						Required:            false,
						Attributes: map[string]schema.Attribute{
							"title_size": schema.Float64Attribute{
								MarkdownDescription: `Explicit title text size`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
							"value_size": schema.Float64Attribute{
								MarkdownDescription: `Explicit value text size`,
								Computed:            false,
								Optional:            true,
								Required:            false,
							},
						},
					},
					"show_threshold_markers": schema.BoolAttribute{
						MarkdownDescription: ` Defaults to true.`,
						Computed:            true,
						Optional:            true,
						Required:            false,
					},
					"orientation": 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{
									"draw_style": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"gradient_mode": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"thresholds_style": schema.SingleNestedAttribute{
										MarkdownDescription: ``,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"mode": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            false,
												Required:            true,
											},
										},
									},
									"line_color": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"line_width": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"line_interpolation": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"line_style": schema.SingleNestedAttribute{
										MarkdownDescription: ``,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"fill": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
											"dash": schema.ListAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
												ElementType:         types.Float64Type,
											},
										},
									},
									"fill_color": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"fill_opacity": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"show_points": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"point_size": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"point_color": schema.StringAttribute{
										MarkdownDescription: ``,
										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,
											},
										},
									},
									"bar_alignment": schema.Int64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"bar_width_factor": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"stacking": schema.SingleNestedAttribute{
										MarkdownDescription: ``,
										Computed:            true,
										Optional:            true,
										Required:            false,
										Attributes: map[string]schema.Attribute{
											"mode": schema.StringAttribute{
												MarkdownDescription: ``,
												Computed:            false,
												Optional:            true,
												Required:            false,
											},
											"group": schema.StringAttribute{
												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,
											},
										},
									},
									"transform": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"span_nulls": schema.StringAttribute{
										MarkdownDescription: `Indicate if null values should be treated as gaps or connected.
When the value is a number, it represents the maximum delta in the
X axis that should be considered connected.  For timeseries, this is milliseconds`,
										Computed: false,
										Optional: true,
										Required: false,
									},
									"fill_below_to": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"point_symbol": schema.StringAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"axis_centered_zero": schema.BoolAttribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
									"bar_max_width": schema.Float64Attribute{
										MarkdownDescription: ``,
										Computed:            false,
										Optional:            true,
										Required:            false,
									},
								},
							},
						},
					},
					"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 *PanelGaugeDataSource) Configure(ctx context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
}

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

	// 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)...)
}