Php/json to code #575

K-Phoen · 2024-10-03T22:06:01Z

No description provided.

github-actions · 2024-10-03T22:09:42Z

Note: in addition to the changes introduced by this PR, the diff includes unreleased changes living in main.

🔎 Changes to `grafana-foundation-sdk@next+cog-v0.0.x`

diff --git a/go/candlestick/candlestickcolors_builder_gen.go b/go/candlestick/candlestickcolors_builder_gen.go
new file mode 100644
index 00000000..b41a1099
--- /dev/null
+++ b/go/candlestick/candlestickcolors_builder_gen.go
@@ -0,0 +1,64 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package candlestick
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[CandlestickColors] = (*CandlestickColorsBuilder)(nil)
+
+type CandlestickColorsBuilder struct {
+	internal *CandlestickColors
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCandlestickColorsBuilder() *CandlestickColorsBuilder {
+	resource := &CandlestickColors{}
+	builder := &CandlestickColorsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *CandlestickColorsBuilder) Build() (CandlestickColors, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CandlestickColors", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CandlestickColors{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *CandlestickColorsBuilder) Up(up string) *CandlestickColorsBuilder {
+	builder.internal.Up = up
+
+	return builder
+}
+
+func (builder *CandlestickColorsBuilder) Down(down string) *CandlestickColorsBuilder {
+	builder.internal.Down = down
+
+	return builder
+}
+
+func (builder *CandlestickColorsBuilder) Flat(flat string) *CandlestickColorsBuilder {
+	builder.internal.Flat = flat
+
+	return builder
+}
+
+func (builder *CandlestickColorsBuilder) applyDefaults() {
+	builder.Up("green")
+	builder.Down("red")
+	builder.Flat("gray")
+}
diff --git a/go/candlestick/candlestickfieldmap_builder_gen.go b/go/candlestick/candlestickfieldmap_builder_gen.go
new file mode 100644
index 00000000..7d988405
--- /dev/null
+++ b/go/candlestick/candlestickfieldmap_builder_gen.go
@@ -0,0 +1,78 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package candlestick
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[CandlestickFieldMap] = (*CandlestickFieldMapBuilder)(nil)
+
+type CandlestickFieldMapBuilder struct {
+	internal *CandlestickFieldMap
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCandlestickFieldMapBuilder() *CandlestickFieldMapBuilder {
+	resource := &CandlestickFieldMap{}
+	builder := &CandlestickFieldMapBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *CandlestickFieldMapBuilder) Build() (CandlestickFieldMap, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CandlestickFieldMap", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CandlestickFieldMap{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Corresponds to the starting value of the given period
+func (builder *CandlestickFieldMapBuilder) Open(open string) *CandlestickFieldMapBuilder {
+	builder.internal.Open = &open
+
+	return builder
+}
+
+// Corresponds to the highest value of the given period
+func (builder *CandlestickFieldMapBuilder) High(high string) *CandlestickFieldMapBuilder {
+	builder.internal.High = &high
+
+	return builder
+}
+
+// Corresponds to the lowest value of the given period
+func (builder *CandlestickFieldMapBuilder) Low(low string) *CandlestickFieldMapBuilder {
+	builder.internal.Low = &low
+
+	return builder
+}
+
+// Corresponds to the final (end) value of the given period
+func (builder *CandlestickFieldMapBuilder) Close(close string) *CandlestickFieldMapBuilder {
+	builder.internal.Close = &close
+
+	return builder
+}
+
+// Corresponds to the sample count in the given period. (e.g. number of trades)
+func (builder *CandlestickFieldMapBuilder) Volume(volume string) *CandlestickFieldMapBuilder {
+	builder.internal.Volume = &volume
+
+	return builder
+}
+
+func (builder *CandlestickFieldMapBuilder) applyDefaults() {
+}
diff --git a/go/candlestick/panel_builder_gen.go b/go/candlestick/panel_builder_gen.go
index cce62bbe..342b5962 100644
--- a/go/candlestick/panel_builder_gen.go
+++ b/go/candlestick/panel_builder_gen.go
@@ -449,21 +449,31 @@ func (builder *PanelBuilder) ColorStrategy(colorStrategy ColorStrategy) *PanelBu
 }
 
 // Map fields to appropriate dimension
-func (builder *PanelBuilder) Fields(fields CandlestickFieldMap) *PanelBuilder {
+func (builder *PanelBuilder) Fields(fields cog.Builder[CandlestickFieldMap]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Fields = fields
+	fieldsResource, err := fields.Build()
+	if err != nil {
+		builder.errors["options.fields"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Fields = fieldsResource
 
 	return builder
 }
 
 // Set which colors are used when the price movement is up or down
-func (builder *PanelBuilder) Colors(colors CandlestickColors) *PanelBuilder {
+func (builder *PanelBuilder) Colors(colors cog.Builder[CandlestickColors]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Colors = colors
+	colorsResource, err := colors.Build()
+	if err != nil {
+		builder.errors["options.colors"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Colors = colorsResource
 
 	return builder
 }
@@ -925,10 +935,10 @@ func (builder *PanelBuilder) applyDefaults() {
 	builder.Mode("candles+volume")
 	builder.CandleStyle("candles")
 	builder.ColorStrategy("open-close")
-	builder.Colors(CandlestickColors{
-		Down: "red",
-		Flat: "gray",
-		Up:   "green",
-	})
+	builder.Colors(NewCandlestickColorsBuilder().
+		Down("red").
+		Flat("gray").
+		Up("green"),
+	)
 	builder.IncludeAllFields(false)
 }
diff --git a/go/canvas/backgroundconfig_builder_gen.go b/go/canvas/backgroundconfig_builder_gen.go
new file mode 100644
index 00000000..6aa8581d
--- /dev/null
+++ b/go/canvas/backgroundconfig_builder_gen.go
@@ -0,0 +1,72 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[BackgroundConfig] = (*BackgroundConfigBuilder)(nil)
+
+type BackgroundConfigBuilder struct {
+	internal *BackgroundConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewBackgroundConfigBuilder() *BackgroundConfigBuilder {
+	resource := &BackgroundConfig{}
+	builder := &BackgroundConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *BackgroundConfigBuilder) Build() (BackgroundConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("BackgroundConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return BackgroundConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *BackgroundConfigBuilder) Color(color cog.Builder[common.ColorDimensionConfig]) *BackgroundConfigBuilder {
+	colorResource, err := color.Build()
+	if err != nil {
+		builder.errors["color"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Color = &colorResource
+
+	return builder
+}
+
+func (builder *BackgroundConfigBuilder) Image(image cog.Builder[common.ResourceDimensionConfig]) *BackgroundConfigBuilder {
+	imageResource, err := image.Build()
+	if err != nil {
+		builder.errors["image"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Image = &imageResource
+
+	return builder
+}
+
+func (builder *BackgroundConfigBuilder) Size(size BackgroundImageSize) *BackgroundConfigBuilder {
+	builder.internal.Size = &size
+
+	return builder
+}
+
+func (builder *BackgroundConfigBuilder) applyDefaults() {
+}
diff --git a/go/canvas/canvasconnection_builder_gen.go b/go/canvas/canvasconnection_builder_gen.go
new file mode 100644
index 00000000..c7fe30b8
--- /dev/null
+++ b/go/canvas/canvasconnection_builder_gen.go
@@ -0,0 +1,137 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[CanvasConnection] = (*CanvasConnectionBuilder)(nil)
+
+type CanvasConnectionBuilder struct {
+	internal *CanvasConnection
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCanvasConnectionBuilder() *CanvasConnectionBuilder {
+	resource := &CanvasConnection{}
+	builder := &CanvasConnectionBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Build() (CanvasConnection, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CanvasConnection", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CanvasConnection{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *CanvasConnectionBuilder) Source(source cog.Builder[ConnectionCoordinates]) *CanvasConnectionBuilder {
+	sourceResource, err := source.Build()
+	if err != nil {
+		builder.errors["source"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Source = sourceResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Target(target cog.Builder[ConnectionCoordinates]) *CanvasConnectionBuilder {
+	targetResource, err := target.Build()
+	if err != nil {
+		builder.errors["target"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Target = targetResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) TargetName(targetName string) *CanvasConnectionBuilder {
+	builder.internal.TargetName = &targetName
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Path(path ConnectionPath) *CanvasConnectionBuilder {
+	builder.internal.Path = path
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Color(color cog.Builder[common.ColorDimensionConfig]) *CanvasConnectionBuilder {
+	colorResource, err := color.Build()
+	if err != nil {
+		builder.errors["color"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Color = &colorResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Size(size cog.Builder[common.ScaleDimensionConfig]) *CanvasConnectionBuilder {
+	sizeResource, err := size.Build()
+	if err != nil {
+		builder.errors["size"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Size = &sizeResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) Vertices(vertices []cog.Builder[ConnectionCoordinates]) *CanvasConnectionBuilder {
+	verticesResources := make([]ConnectionCoordinates, 0, len(vertices))
+	for _, r1 := range vertices {
+		verticesDepth1, err := r1.Build()
+		if err != nil {
+			builder.errors["vertices"] = err.(cog.BuildErrors)
+			return builder
+		}
+		verticesResources = append(verticesResources, verticesDepth1)
+	}
+	builder.internal.Vertices = verticesResources
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) SourceOriginal(sourceOriginal cog.Builder[ConnectionCoordinates]) *CanvasConnectionBuilder {
+	sourceOriginalResource, err := sourceOriginal.Build()
+	if err != nil {
+		builder.errors["sourceOriginal"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.SourceOriginal = &sourceOriginalResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) TargetOriginal(targetOriginal cog.Builder[ConnectionCoordinates]) *CanvasConnectionBuilder {
+	targetOriginalResource, err := targetOriginal.Build()
+	if err != nil {
+		builder.errors["targetOriginal"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.TargetOriginal = &targetOriginalResource
+
+	return builder
+}
+
+func (builder *CanvasConnectionBuilder) applyDefaults() {
+}
diff --git a/go/canvas/canvaselementoptions_builder_gen.go b/go/canvas/canvaselementoptions_builder_gen.go
new file mode 100644
index 00000000..e17787cd
--- /dev/null
+++ b/go/canvas/canvaselementoptions_builder_gen.go
@@ -0,0 +1,121 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[CanvasElementOptions] = (*CanvasElementOptionsBuilder)(nil)
+
+type CanvasElementOptionsBuilder struct {
+	internal *CanvasElementOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCanvasElementOptionsBuilder() *CanvasElementOptionsBuilder {
+	resource := &CanvasElementOptions{}
+	builder := &CanvasElementOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Build() (CanvasElementOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CanvasElementOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CanvasElementOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *CanvasElementOptionsBuilder) Name(name string) *CanvasElementOptionsBuilder {
+	builder.internal.Name = name
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Type(typeArg string) *CanvasElementOptionsBuilder {
+	builder.internal.Type = typeArg
+
+	return builder
+}
+
+// TODO: figure out how to define this (element config(s))
+func (builder *CanvasElementOptionsBuilder) Config(config any) *CanvasElementOptionsBuilder {
+	builder.internal.Config = &config
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Constraint(constraint cog.Builder[Constraint]) *CanvasElementOptionsBuilder {
+	constraintResource, err := constraint.Build()
+	if err != nil {
+		builder.errors["constraint"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Constraint = &constraintResource
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Placement(placement cog.Builder[Placement]) *CanvasElementOptionsBuilder {
+	placementResource, err := placement.Build()
+	if err != nil {
+		builder.errors["placement"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Placement = &placementResource
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Background(background cog.Builder[BackgroundConfig]) *CanvasElementOptionsBuilder {
+	backgroundResource, err := background.Build()
+	if err != nil {
+		builder.errors["background"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Background = &backgroundResource
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Border(border cog.Builder[LineConfig]) *CanvasElementOptionsBuilder {
+	borderResource, err := border.Build()
+	if err != nil {
+		builder.errors["border"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Border = &borderResource
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) Connections(connections []cog.Builder[CanvasConnection]) *CanvasElementOptionsBuilder {
+	connectionsResources := make([]CanvasConnection, 0, len(connections))
+	for _, r1 := range connections {
+		connectionsDepth1, err := r1.Build()
+		if err != nil {
+			builder.errors["connections"] = err.(cog.BuildErrors)
+			return builder
+		}
+		connectionsResources = append(connectionsResources, connectionsDepth1)
+	}
+	builder.internal.Connections = connectionsResources
+
+	return builder
+}
+
+func (builder *CanvasElementOptionsBuilder) applyDefaults() {
+}
diff --git a/go/canvas/canvasoptionsroot_builder_gen.go b/go/canvas/canvasoptionsroot_builder_gen.go
new file mode 100644
index 00000000..0f3c98f5
--- /dev/null
+++ b/go/canvas/canvasoptionsroot_builder_gen.go
@@ -0,0 +1,67 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[CanvasOptionsRoot] = (*CanvasOptionsRootBuilder)(nil)
+
+type CanvasOptionsRootBuilder struct {
+	internal *CanvasOptionsRoot
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCanvasOptionsRootBuilder() *CanvasOptionsRootBuilder {
+	resource := &CanvasOptionsRoot{}
+	builder := &CanvasOptionsRootBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+	builder.internal.Type = "frame"
+
+	return builder
+}
+
+func (builder *CanvasOptionsRootBuilder) Build() (CanvasOptionsRoot, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CanvasOptionsRoot", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CanvasOptionsRoot{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Name of the root element
+func (builder *CanvasOptionsRootBuilder) Name(name string) *CanvasOptionsRootBuilder {
+	builder.internal.Name = name
+
+	return builder
+}
+
+// The list of canvas elements attached to the root element
+func (builder *CanvasOptionsRootBuilder) Elements(elements []cog.Builder[CanvasElementOptions]) *CanvasOptionsRootBuilder {
+	elementsResources := make([]CanvasElementOptions, 0, len(elements))
+	for _, r1 := range elements {
+		elementsDepth1, err := r1.Build()
+		if err != nil {
+			builder.errors["elements"] = err.(cog.BuildErrors)
+			return builder
+		}
+		elementsResources = append(elementsResources, elementsDepth1)
+	}
+	builder.internal.Elements = elementsResources
+
+	return builder
+}
+
+func (builder *CanvasOptionsRootBuilder) applyDefaults() {
+}
diff --git a/go/canvas/connectioncoordinates_builder_gen.go b/go/canvas/connectioncoordinates_builder_gen.go
new file mode 100644
index 00000000..03a7e8a3
--- /dev/null
+++ b/go/canvas/connectioncoordinates_builder_gen.go
@@ -0,0 +1,55 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[ConnectionCoordinates] = (*ConnectionCoordinatesBuilder)(nil)
+
+type ConnectionCoordinatesBuilder struct {
+	internal *ConnectionCoordinates
+	errors   map[string]cog.BuildErrors
+}
+
+func NewConnectionCoordinatesBuilder() *ConnectionCoordinatesBuilder {
+	resource := &ConnectionCoordinates{}
+	builder := &ConnectionCoordinatesBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *ConnectionCoordinatesBuilder) Build() (ConnectionCoordinates, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("ConnectionCoordinates", err)...)
+	}
+
+	if len(errs) != 0 {
+		return ConnectionCoordinates{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *ConnectionCoordinatesBuilder) X(x float64) *ConnectionCoordinatesBuilder {
+	builder.internal.X = x
+
+	return builder
+}
+
+func (builder *ConnectionCoordinatesBuilder) Y(y float64) *ConnectionCoordinatesBuilder {
+	builder.internal.Y = y
+
+	return builder
+}
+
+func (builder *ConnectionCoordinatesBuilder) applyDefaults() {
+}
diff --git a/go/canvas/constraint_builder_gen.go b/go/canvas/constraint_builder_gen.go
new file mode 100644
index 00000000..8d50ad08
--- /dev/null
+++ b/go/canvas/constraint_builder_gen.go
@@ -0,0 +1,55 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[Constraint] = (*ConstraintBuilder)(nil)
+
+type ConstraintBuilder struct {
+	internal *Constraint
+	errors   map[string]cog.BuildErrors
+}
+
+func NewConstraintBuilder() *ConstraintBuilder {
+	resource := &Constraint{}
+	builder := &ConstraintBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *ConstraintBuilder) Build() (Constraint, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("Constraint", err)...)
+	}
+
+	if len(errs) != 0 {
+		return Constraint{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *ConstraintBuilder) Horizontal(horizontal HorizontalConstraint) *ConstraintBuilder {
+	builder.internal.Horizontal = &horizontal
+
+	return builder
+}
+
+func (builder *ConstraintBuilder) Vertical(vertical VerticalConstraint) *ConstraintBuilder {
+	builder.internal.Vertical = &vertical
+
+	return builder
+}
+
+func (builder *ConstraintBuilder) applyDefaults() {
+}
diff --git a/go/canvas/lineconfig_builder_gen.go b/go/canvas/lineconfig_builder_gen.go
new file mode 100644
index 00000000..5d40e937
--- /dev/null
+++ b/go/canvas/lineconfig_builder_gen.go
@@ -0,0 +1,67 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[LineConfig] = (*LineConfigBuilder)(nil)
+
+type LineConfigBuilder struct {
+	internal *LineConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewLineConfigBuilder() *LineConfigBuilder {
+	resource := &LineConfig{}
+	builder := &LineConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *LineConfigBuilder) Build() (LineConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("LineConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return LineConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *LineConfigBuilder) Color(color cog.Builder[common.ColorDimensionConfig]) *LineConfigBuilder {
+	colorResource, err := color.Build()
+	if err != nil {
+		builder.errors["color"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Color = &colorResource
+
+	return builder
+}
+
+func (builder *LineConfigBuilder) Width(width float64) *LineConfigBuilder {
+	builder.internal.Width = &width
+
+	return builder
+}
+
+func (builder *LineConfigBuilder) Radius(radius float64) *LineConfigBuilder {
+	builder.internal.Radius = &radius
+
+	return builder
+}
+
+func (builder *LineConfigBuilder) applyDefaults() {
+}
diff --git a/go/canvas/panel_builder_gen.go b/go/canvas/panel_builder_gen.go
index 51cf72ea..190927fb 100644
--- a/go/canvas/panel_builder_gen.go
+++ b/go/canvas/panel_builder_gen.go
@@ -459,11 +459,16 @@ func (builder *PanelBuilder) InfinitePan(infinitePan bool) *PanelBuilder {
 
 // The root element of canvas (frame), where all canvas elements are nested
 // TODO: Figure out how to define a default value for this
-func (builder *PanelBuilder) Root(root CanvasOptionsRoot) *PanelBuilder {
+func (builder *PanelBuilder) Root(root cog.Builder[CanvasOptionsRoot]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Root = root
+	rootResource, err := root.Build()
+	if err != nil {
+		builder.errors["options.root"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Root = rootResource
 
 	return builder
 }
diff --git a/go/canvas/placement_builder_gen.go b/go/canvas/placement_builder_gen.go
new file mode 100644
index 00000000..370ae711
--- /dev/null
+++ b/go/canvas/placement_builder_gen.go
@@ -0,0 +1,85 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package canvas
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[Placement] = (*PlacementBuilder)(nil)
+
+type PlacementBuilder struct {
+	internal *Placement
+	errors   map[string]cog.BuildErrors
+}
+
+func NewPlacementBuilder() *PlacementBuilder {
+	resource := &Placement{}
+	builder := &PlacementBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Build() (Placement, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("Placement", err)...)
+	}
+
+	if len(errs) != 0 {
+		return Placement{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *PlacementBuilder) Top(top float64) *PlacementBuilder {
+	builder.internal.Top = &top
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Left(left float64) *PlacementBuilder {
+	builder.internal.Left = &left
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Right(right float64) *PlacementBuilder {
+	builder.internal.Right = &right
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Bottom(bottom float64) *PlacementBuilder {
+	builder.internal.Bottom = &bottom
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Width(width float64) *PlacementBuilder {
+	builder.internal.Width = &width
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Height(height float64) *PlacementBuilder {
+	builder.internal.Height = &height
+
+	return builder
+}
+
+func (builder *PlacementBuilder) Rotation(rotation float64) *PlacementBuilder {
+	builder.internal.Rotation = &rotation
+
+	return builder
+}
+
+func (builder *PlacementBuilder) applyDefaults() {
+}
diff --git a/go/debug/panel_builder_gen.go b/go/debug/panel_builder_gen.go
index e8e5c40b..a94ada0f 100644
--- a/go/debug/panel_builder_gen.go
+++ b/go/debug/panel_builder_gen.go
@@ -426,11 +426,16 @@ func (builder *PanelBuilder) Mode(mode DebugMode) *PanelBuilder {
 	return builder
 }
 
-func (builder *PanelBuilder) Counters(counters UpdateConfig) *PanelBuilder {
+func (builder *PanelBuilder) Counters(counters cog.Builder[UpdateConfig]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Counters = &counters
+	countersResource, err := counters.Build()
+	if err != nil {
+		builder.errors["options.counters"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Counters = &countersResource
 
 	return builder
 }
diff --git a/go/debug/updateconfig_builder_gen.go b/go/debug/updateconfig_builder_gen.go
new file mode 100644
index 00000000..1449a22d
--- /dev/null
+++ b/go/debug/updateconfig_builder_gen.go
@@ -0,0 +1,61 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package debug
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[UpdateConfig] = (*UpdateConfigBuilder)(nil)
+
+type UpdateConfigBuilder struct {
+	internal *UpdateConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewUpdateConfigBuilder() *UpdateConfigBuilder {
+	resource := &UpdateConfig{}
+	builder := &UpdateConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *UpdateConfigBuilder) Build() (UpdateConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("UpdateConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return UpdateConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *UpdateConfigBuilder) Render(render bool) *UpdateConfigBuilder {
+	builder.internal.Render = render
+
+	return builder
+}
+
+func (builder *UpdateConfigBuilder) DataChanged(dataChanged bool) *UpdateConfigBuilder {
+	builder.internal.DataChanged = dataChanged
+
+	return builder
+}
+
+func (builder *UpdateConfigBuilder) SchemaChanged(schemaChanged bool) *UpdateConfigBuilder {
+	builder.internal.SchemaChanged = schemaChanged
+
+	return builder
+}
+
+func (builder *UpdateConfigBuilder) applyDefaults() {
+}
diff --git a/go/geomap/controlsoptions_builder_gen.go b/go/geomap/controlsoptions_builder_gen.go
new file mode 100644
index 00000000..23dd2f16
--- /dev/null
+++ b/go/geomap/controlsoptions_builder_gen.go
@@ -0,0 +1,85 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package geomap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[ControlsOptions] = (*ControlsOptionsBuilder)(nil)
+
+type ControlsOptionsBuilder struct {
+	internal *ControlsOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewControlsOptionsBuilder() *ControlsOptionsBuilder {
+	resource := &ControlsOptions{}
+	builder := &ControlsOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *ControlsOptionsBuilder) Build() (ControlsOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("ControlsOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return ControlsOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Zoom (upper left)
+func (builder *ControlsOptionsBuilder) ShowZoom(showZoom bool) *ControlsOptionsBuilder {
+	builder.internal.ShowZoom = &showZoom
+
+	return builder
+}
+
+// let the mouse wheel zoom
+func (builder *ControlsOptionsBuilder) MouseWheelZoom(mouseWheelZoom bool) *ControlsOptionsBuilder {
+	builder.internal.MouseWheelZoom = &mouseWheelZoom
+
+	return builder
+}
+
+// Lower right
+func (builder *ControlsOptionsBuilder) ShowAttribution(showAttribution bool) *ControlsOptionsBuilder {
+	builder.internal.ShowAttribution = &showAttribution
+
+	return builder
+}
+
+// Scale options
+func (builder *ControlsOptionsBuilder) ShowScale(showScale bool) *ControlsOptionsBuilder {
+	builder.internal.ShowScale = &showScale
+
+	return builder
+}
+
+// Show debug
+func (builder *ControlsOptionsBuilder) ShowDebug(showDebug bool) *ControlsOptionsBuilder {
+	builder.internal.ShowDebug = &showDebug
+
+	return builder
+}
+
+// Show measure
+func (builder *ControlsOptionsBuilder) ShowMeasure(showMeasure bool) *ControlsOptionsBuilder {
+	builder.internal.ShowMeasure = &showMeasure
+
+	return builder
+}
+
+func (builder *ControlsOptionsBuilder) applyDefaults() {
+}
diff --git a/go/geomap/mapviewconfig_builder_gen.go b/go/geomap/mapviewconfig_builder_gen.go
new file mode 100644
index 00000000..f58fae81
--- /dev/null
+++ b/go/geomap/mapviewconfig_builder_gen.go
@@ -0,0 +1,114 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package geomap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[MapViewConfig] = (*MapViewConfigBuilder)(nil)
+
+type MapViewConfigBuilder struct {
+	internal *MapViewConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewMapViewConfigBuilder() *MapViewConfigBuilder {
+	resource := &MapViewConfig{}
+	builder := &MapViewConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Build() (MapViewConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("MapViewConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return MapViewConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *MapViewConfigBuilder) Id(id string) *MapViewConfigBuilder {
+	builder.internal.Id = id
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Lat(lat int64) *MapViewConfigBuilder {
+	builder.internal.Lat = &lat
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Lon(lon int64) *MapViewConfigBuilder {
+	builder.internal.Lon = &lon
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Zoom(zoom int64) *MapViewConfigBuilder {
+	builder.internal.Zoom = &zoom
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) MinZoom(minZoom int64) *MapViewConfigBuilder {
+	builder.internal.MinZoom = &minZoom
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) MaxZoom(maxZoom int64) *MapViewConfigBuilder {
+	builder.internal.MaxZoom = &maxZoom
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Padding(padding int64) *MapViewConfigBuilder {
+	builder.internal.Padding = &padding
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) AllLayers(allLayers bool) *MapViewConfigBuilder {
+	builder.internal.AllLayers = &allLayers
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) LastOnly(lastOnly bool) *MapViewConfigBuilder {
+	builder.internal.LastOnly = &lastOnly
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Layer(layer string) *MapViewConfigBuilder {
+	builder.internal.Layer = &layer
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) Shared(shared bool) *MapViewConfigBuilder {
+	builder.internal.Shared = &shared
+
+	return builder
+}
+
+func (builder *MapViewConfigBuilder) applyDefaults() {
+	builder.Id("zero")
+	builder.Lat(0)
+	builder.Lon(0)
+	builder.Zoom(1)
+	builder.AllLayers(true)
+}
diff --git a/go/geomap/panel_builder_gen.go b/go/geomap/panel_builder_gen.go
index a1fda15b..d90a9f9d 100644
--- a/go/geomap/panel_builder_gen.go
+++ b/go/geomap/panel_builder_gen.go
@@ -418,20 +418,30 @@ func (builder *PanelBuilder) WithOverride(matcher dashboard.MatcherConfig, prope
 	return builder
 }
 
-func (builder *PanelBuilder) View(view MapViewConfig) *PanelBuilder {
+func (builder *PanelBuilder) View(view cog.Builder[MapViewConfig]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).View = view
+	viewResource, err := view.Build()
+	if err != nil {
+		builder.errors["options.view"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).View = viewResource
 
 	return builder
 }
 
-func (builder *PanelBuilder) Controls(controls ControlsOptions) *PanelBuilder {
+func (builder *PanelBuilder) Controls(controls cog.Builder[ControlsOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Controls = controls
+	controlsResource, err := controls.Build()
+	if err != nil {
+		builder.errors["options.controls"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Controls = controlsResource
 
 	return builder
 }
@@ -468,11 +478,16 @@ func (builder *PanelBuilder) Layers(layers []cog.Builder[common.MapLayerOptions]
 	return builder
 }
 
-func (builder *PanelBuilder) Tooltip(tooltip TooltipOptions) *PanelBuilder {
+func (builder *PanelBuilder) Tooltip(tooltip cog.Builder[TooltipOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Tooltip = tooltip
+	tooltipResource, err := tooltip.Build()
+	if err != nil {
+		builder.errors["options.tooltip"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Tooltip = tooltipResource
 
 	return builder
 }
diff --git a/go/geomap/tooltipoptions_builder_gen.go b/go/geomap/tooltipoptions_builder_gen.go
new file mode 100644
index 00000000..8e229014
--- /dev/null
+++ b/go/geomap/tooltipoptions_builder_gen.go
@@ -0,0 +1,49 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package geomap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[TooltipOptions] = (*TooltipOptionsBuilder)(nil)
+
+type TooltipOptionsBuilder struct {
+	internal *TooltipOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewTooltipOptionsBuilder() *TooltipOptionsBuilder {
+	resource := &TooltipOptions{}
+	builder := &TooltipOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *TooltipOptionsBuilder) Build() (TooltipOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("TooltipOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return TooltipOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+func (builder *TooltipOptionsBuilder) Mode(mode TooltipMode) *TooltipOptionsBuilder {
+	builder.internal.Mode = mode
+
+	return builder
+}
+
+func (builder *TooltipOptionsBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/cellvalues_builder_gen.go b/go/heatmap/cellvalues_builder_gen.go
new file mode 100644
index 00000000..e4c2de68
--- /dev/null
+++ b/go/heatmap/cellvalues_builder_gen.go
@@ -0,0 +1,58 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[CellValues] = (*CellValuesBuilder)(nil)
+
+// Controls cell value options
+type CellValuesBuilder struct {
+	internal *CellValues
+	errors   map[string]cog.BuildErrors
+}
+
+func NewCellValuesBuilder() *CellValuesBuilder {
+	resource := &CellValues{}
+	builder := &CellValuesBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *CellValuesBuilder) Build() (CellValues, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("CellValues", err)...)
+	}
+
+	if len(errs) != 0 {
+		return CellValues{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Controls the cell value unit
+func (builder *CellValuesBuilder) Unit(unit string) *CellValuesBuilder {
+	builder.internal.Unit = &unit
+
+	return builder
+}
+
+// Controls the number of decimals for cell values
+func (builder *CellValuesBuilder) Decimals(decimals float32) *CellValuesBuilder {
+	builder.internal.Decimals = &decimals
+
+	return builder
+}
+
+func (builder *CellValuesBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/exemplarconfig_builder_gen.go b/go/heatmap/exemplarconfig_builder_gen.go
new file mode 100644
index 00000000..01bf3031
--- /dev/null
+++ b/go/heatmap/exemplarconfig_builder_gen.go
@@ -0,0 +1,51 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[ExemplarConfig] = (*ExemplarConfigBuilder)(nil)
+
+// Controls exemplar options
+type ExemplarConfigBuilder struct {
+	internal *ExemplarConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewExemplarConfigBuilder() *ExemplarConfigBuilder {
+	resource := &ExemplarConfig{}
+	builder := &ExemplarConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *ExemplarConfigBuilder) Build() (ExemplarConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("ExemplarConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return ExemplarConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Sets the color of the exemplar markers
+func (builder *ExemplarConfigBuilder) Color(color string) *ExemplarConfigBuilder {
+	builder.internal.Color = color
+
+	return builder
+}
+
+func (builder *ExemplarConfigBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/filtervaluerange_builder_gen.go b/go/heatmap/filtervaluerange_builder_gen.go
new file mode 100644
index 00000000..8e3d5098
--- /dev/null
+++ b/go/heatmap/filtervaluerange_builder_gen.go
@@ -0,0 +1,58 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[FilterValueRange] = (*FilterValueRangeBuilder)(nil)
+
+// Controls the value filter range
+type FilterValueRangeBuilder struct {
+	internal *FilterValueRange
+	errors   map[string]cog.BuildErrors
+}
+
+func NewFilterValueRangeBuilder() *FilterValueRangeBuilder {
+	resource := &FilterValueRange{}
+	builder := &FilterValueRangeBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *FilterValueRangeBuilder) Build() (FilterValueRange, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("FilterValueRange", err)...)
+	}
+
+	if len(errs) != 0 {
+		return FilterValueRange{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Sets the filter range to values less than or equal to the given value
+func (builder *FilterValueRangeBuilder) Le(le float32) *FilterValueRangeBuilder {
+	builder.internal.Le = &le
+
+	return builder
+}
+
+// Sets the filter range to values greater than or equal to the given value
+func (builder *FilterValueRangeBuilder) Ge(ge float32) *FilterValueRangeBuilder {
+	builder.internal.Ge = &ge
+
+	return builder
+}
+
+func (builder *FilterValueRangeBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/heatmapcoloroptions_builder_gen.go b/go/heatmap/heatmapcoloroptions_builder_gen.go
new file mode 100644
index 00000000..991c003a
--- /dev/null
+++ b/go/heatmap/heatmapcoloroptions_builder_gen.go
@@ -0,0 +1,117 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	"errors"
+
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[HeatmapColorOptions] = (*HeatmapColorOptionsBuilder)(nil)
+
+// Controls various color options
+type HeatmapColorOptionsBuilder struct {
+	internal *HeatmapColorOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewHeatmapColorOptionsBuilder() *HeatmapColorOptionsBuilder {
+	resource := &HeatmapColorOptions{}
+	builder := &HeatmapColorOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *HeatmapColorOptionsBuilder) Build() (HeatmapColorOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("HeatmapColorOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return HeatmapColorOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Sets the color mode
+func (builder *HeatmapColorOptionsBuilder) Mode(mode HeatmapColorMode) *HeatmapColorOptionsBuilder {
+	builder.internal.Mode = &mode
+
+	return builder
+}
+
+// Controls the color scheme used
+func (builder *HeatmapColorOptionsBuilder) Scheme(scheme string) *HeatmapColorOptionsBuilder {
+	builder.internal.Scheme = scheme
+
+	return builder
+}
+
+// Controls the color fill when in opacity mode
+func (builder *HeatmapColorOptionsBuilder) Fill(fill string) *HeatmapColorOptionsBuilder {
+	builder.internal.Fill = fill
+
+	return builder
+}
+
+// Controls the color scale
+func (builder *HeatmapColorOptionsBuilder) Scale(scale HeatmapColorScale) *HeatmapColorOptionsBuilder {
+	builder.internal.Scale = &scale
+
+	return builder
+}
+
+// Controls the exponent when scale is set to exponential
+func (builder *HeatmapColorOptionsBuilder) Exponent(exponent float32) *HeatmapColorOptionsBuilder {
+	builder.internal.Exponent = exponent
+
+	return builder
+}
+
+// Controls the number of color steps
+func (builder *HeatmapColorOptionsBuilder) Steps(steps uint64) *HeatmapColorOptionsBuilder {
+	if !(steps >= 2) {
+		builder.errors["steps"] = cog.MakeBuildErrors("steps", errors.New("steps must be >= 2"))
+		return builder
+	}
+	if !(steps <= 128) {
+		builder.errors["steps"] = cog.MakeBuildErrors("steps", errors.New("steps must be <= 128"))
+		return builder
+	}
+	builder.internal.Steps = steps
+
+	return builder
+}
+
+// Reverses the color scheme
+func (builder *HeatmapColorOptionsBuilder) Reverse(reverse bool) *HeatmapColorOptionsBuilder {
+	builder.internal.Reverse = reverse
+
+	return builder
+}
+
+// Sets the minimum value for the color scale
+func (builder *HeatmapColorOptionsBuilder) Min(min float32) *HeatmapColorOptionsBuilder {
+	builder.internal.Min = &min
+
+	return builder
+}
+
+// Sets the maximum value for the color scale
+func (builder *HeatmapColorOptionsBuilder) Max(max float32) *HeatmapColorOptionsBuilder {
+	builder.internal.Max = &max
+
+	return builder
+}
+
+func (builder *HeatmapColorOptionsBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/heatmaplegend_builder_gen.go b/go/heatmap/heatmaplegend_builder_gen.go
new file mode 100644
index 00000000..b07453d7
--- /dev/null
+++ b/go/heatmap/heatmaplegend_builder_gen.go
@@ -0,0 +1,51 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[HeatmapLegend] = (*HeatmapLegendBuilder)(nil)
+
+// Controls legend options
+type HeatmapLegendBuilder struct {
+	internal *HeatmapLegend
+	errors   map[string]cog.BuildErrors
+}
+
+func NewHeatmapLegendBuilder() *HeatmapLegendBuilder {
+	resource := &HeatmapLegend{}
+	builder := &HeatmapLegendBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *HeatmapLegendBuilder) Build() (HeatmapLegend, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("HeatmapLegend", err)...)
+	}
+
+	if len(errs) != 0 {
+		return HeatmapLegend{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Controls if the legend is shown
+func (builder *HeatmapLegendBuilder) Show(show bool) *HeatmapLegendBuilder {
+	builder.internal.Show = show
+
+	return builder
+}
+
+func (builder *HeatmapLegendBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/heatmaptooltip_builder_gen.go b/go/heatmap/heatmaptooltip_builder_gen.go
new file mode 100644
index 00000000..472aa058
--- /dev/null
+++ b/go/heatmap/heatmaptooltip_builder_gen.go
@@ -0,0 +1,78 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[HeatmapTooltip] = (*HeatmapTooltipBuilder)(nil)
+
+// Controls tooltip options
+type HeatmapTooltipBuilder struct {
+	internal *HeatmapTooltip
+	errors   map[string]cog.BuildErrors
+}
+
+func NewHeatmapTooltipBuilder() *HeatmapTooltipBuilder {
+	resource := &HeatmapTooltip{}
+	builder := &HeatmapTooltipBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *HeatmapTooltipBuilder) Build() (HeatmapTooltip, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("HeatmapTooltip", err)...)
+	}
+
+	if len(errs) != 0 {
+		return HeatmapTooltip{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Controls how the tooltip is shown
+func (builder *HeatmapTooltipBuilder) Mode(mode common.TooltipDisplayMode) *HeatmapTooltipBuilder {
+	builder.internal.Mode = mode
+
+	return builder
+}
+
+func (builder *HeatmapTooltipBuilder) MaxHeight(maxHeight float64) *HeatmapTooltipBuilder {
+	builder.internal.MaxHeight = &maxHeight
+
+	return builder
+}
+
+func (builder *HeatmapTooltipBuilder) MaxWidth(maxWidth float64) *HeatmapTooltipBuilder {
+	builder.internal.MaxWidth = &maxWidth
+
+	return builder
+}
+
+// Controls if the tooltip shows a histogram of the y-axis values
+func (builder *HeatmapTooltipBuilder) YHistogram(yHistogram bool) *HeatmapTooltipBuilder {
+	builder.internal.YHistogram = &yHistogram
+
+	return builder
+}
+
+// Controls if the tooltip shows a color scale in header
+func (builder *HeatmapTooltipBuilder) ShowColorScale(showColorScale bool) *HeatmapTooltipBuilder {
+	builder.internal.ShowColorScale = &showColorScale
+
+	return builder
+}
+
+func (builder *HeatmapTooltipBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/panel_builder_gen.go b/go/heatmap/panel_builder_gen.go
index 0e0c316e..b5542c8c 100644
--- a/go/heatmap/panel_builder_gen.go
+++ b/go/heatmap/panel_builder_gen.go
@@ -444,31 +444,46 @@ func (builder *PanelBuilder) Calculation(calculation cog.Builder[common.HeatmapC
 }
 
 // Controls the color options
-func (builder *PanelBuilder) Color(color HeatmapColorOptions) *PanelBuilder {
+func (builder *PanelBuilder) Color(color cog.Builder[HeatmapColorOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Color = color
+	colorResource, err := color.Build()
+	if err != nil {
+		builder.errors["options.color"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Color = colorResource
 
 	return builder
 }
 
 // Filters values between a given range
-func (builder *PanelBuilder) FilterValues(filterValues FilterValueRange) *PanelBuilder {
+func (builder *PanelBuilder) FilterValues(filterValues cog.Builder[FilterValueRange]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).FilterValues = &filterValues
+	filterValuesResource, err := filterValues.Build()
+	if err != nil {
+		builder.errors["options.filterValues"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).FilterValues = &filterValuesResource
 
 	return builder
 }
 
 // Controls tick alignment and value name when not calculating from data
-func (builder *PanelBuilder) RowsFrame(rowsFrame RowsHeatmapOptions) *PanelBuilder {
+func (builder *PanelBuilder) RowsFrame(rowsFrame cog.Builder[RowsHeatmapOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).RowsFrame = &rowsFrame
+	rowsFrameResource, err := rowsFrame.Build()
+	if err != nil {
+		builder.errors["options.rowsFrame"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).RowsFrame = &rowsFrameResource
 
 	return builder
 }
@@ -512,21 +527,31 @@ func (builder *PanelBuilder) CellRadius(cellRadius float32) *PanelBuilder {
 }
 
 // Controls cell value unit
-func (builder *PanelBuilder) CellValues(cellValues CellValues) *PanelBuilder {
+func (builder *PanelBuilder) CellValues(cellValues cog.Builder[CellValues]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).CellValues = &cellValues
+	cellValuesResource, err := cellValues.Build()
+	if err != nil {
+		builder.errors["options.cellValues"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).CellValues = &cellValuesResource
 
 	return builder
 }
 
 // Controls yAxis placement
-func (builder *PanelBuilder) YAxis(yAxis YAxisConfig) *PanelBuilder {
+func (builder *PanelBuilder) YAxis(yAxis cog.Builder[YAxisConfig]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).YAxis = yAxis
+	yAxisResource, err := yAxis.Build()
+	if err != nil {
+		builder.errors["options.yAxis"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).YAxis = yAxisResource
 
 	return builder
 }
@@ -678,16 +703,16 @@ func (builder *PanelBuilder) applyDefaults() {
 	builder.Height(9)
 	builder.Span(12)
 	builder.Calculate(false)
-	builder.Color(HeatmapColorOptions{
-		Exponent: 0.5,
-		Fill:     "dark-orange",
-		Reverse:  false,
-		Scheme:   "Oranges",
-		Steps:    64,
-	})
-	builder.FilterValues(FilterValueRange{
-		Le: cog.ToPtr[float32](1e-09),
-	})
+	builder.Color(NewHeatmapColorOptionsBuilder().
+		Exponent(0.5).
+		Fill("dark-orange").
+		Reverse(false).
+		Scheme("Oranges").
+		Steps(64),
+	)
+	builder.FilterValues(NewFilterValueRangeBuilder().
+		Le(1e-09),
+	)
 	builder.ShowValue("auto")
 	builder.CellGap(1)
 	builder.ExemplarsColor("rgba(255,0,255,0.7)")
diff --git a/go/heatmap/rowsheatmapoptions_builder_gen.go b/go/heatmap/rowsheatmapoptions_builder_gen.go
new file mode 100644
index 00000000..5e58dd9f
--- /dev/null
+++ b/go/heatmap/rowsheatmapoptions_builder_gen.go
@@ -0,0 +1,59 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[RowsHeatmapOptions] = (*RowsHeatmapOptionsBuilder)(nil)
+
+// Controls frame rows options
+type RowsHeatmapOptionsBuilder struct {
+	internal *RowsHeatmapOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewRowsHeatmapOptionsBuilder() *RowsHeatmapOptionsBuilder {
+	resource := &RowsHeatmapOptions{}
+	builder := &RowsHeatmapOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *RowsHeatmapOptionsBuilder) Build() (RowsHeatmapOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("RowsHeatmapOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return RowsHeatmapOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Sets the name of the cell when not calculating from data
+func (builder *RowsHeatmapOptionsBuilder) Value(value string) *RowsHeatmapOptionsBuilder {
+	builder.internal.Value = &value
+
+	return builder
+}
+
+// Controls tick alignment when not calculating from data
+func (builder *RowsHeatmapOptionsBuilder) Layout(layout common.HeatmapCellLayout) *RowsHeatmapOptionsBuilder {
+	builder.internal.Layout = &layout
+
+	return builder
+}
+
+func (builder *RowsHeatmapOptionsBuilder) applyDefaults() {
+}
diff --git a/go/heatmap/yaxisconfig_builder_gen.go b/go/heatmap/yaxisconfig_builder_gen.go
new file mode 100644
index 00000000..e5a5ef11
--- /dev/null
+++ b/go/heatmap/yaxisconfig_builder_gen.go
@@ -0,0 +1,145 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package heatmap
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+	common "github.com/grafana/grafana-foundation-sdk/go/common"
+)
+
+var _ cog.Builder[YAxisConfig] = (*YAxisConfigBuilder)(nil)
+
+// Configuration options for the yAxis
+type YAxisConfigBuilder struct {
+	internal *YAxisConfig
+	errors   map[string]cog.BuildErrors
+}
+
+func NewYAxisConfigBuilder() *YAxisConfigBuilder {
+	resource := &YAxisConfig{}
+	builder := &YAxisConfigBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) Build() (YAxisConfig, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("YAxisConfig", err)...)
+	}
+
+	if len(errs) != 0 {
+		return YAxisConfig{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Sets the yAxis unit
+func (builder *YAxisConfigBuilder) Unit(unit string) *YAxisConfigBuilder {
+	builder.internal.Unit = &unit
+
+	return builder
+}
+
+// Reverses the yAxis
+func (builder *YAxisConfigBuilder) Reverse(reverse bool) *YAxisConfigBuilder {
+	builder.internal.Reverse = &reverse
+
+	return builder
+}
+
+// Controls the number of decimals for yAxis values
+func (builder *YAxisConfigBuilder) Decimals(decimals float32) *YAxisConfigBuilder {
+	builder.internal.Decimals = &decimals
+
+	return builder
+}
+
+// Sets the minimum value for the yAxis
+func (builder *YAxisConfigBuilder) Min(min float32) *YAxisConfigBuilder {
+	builder.internal.Min = &min
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisPlacement(axisPlacement common.AxisPlacement) *YAxisConfigBuilder {
+	builder.internal.AxisPlacement = &axisPlacement
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisColorMode(axisColorMode common.AxisColorMode) *YAxisConfigBuilder {
+	builder.internal.AxisColorMode = &axisColorMode
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisLabel(axisLabel string) *YAxisConfigBuilder {
+	builder.internal.AxisLabel = &axisLabel
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisWidth(axisWidth float64) *YAxisConfigBuilder {
+	builder.internal.AxisWidth = &axisWidth
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisSoftMin(axisSoftMin float64) *YAxisConfigBuilder {
+	builder.internal.AxisSoftMin = &axisSoftMin
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisSoftMax(axisSoftMax float64) *YAxisConfigBuilder {
+	builder.internal.AxisSoftMax = &axisSoftMax
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisGridShow(axisGridShow bool) *YAxisConfigBuilder {
+	builder.internal.AxisGridShow = &axisGridShow
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) ScaleDistribution(scaleDistribution cog.Builder[common.ScaleDistributionConfig]) *YAxisConfigBuilder {
+	scaleDistributionResource, err := scaleDistribution.Build()
+	if err != nil {
+		builder.errors["scaleDistribution"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.ScaleDistribution = &scaleDistributionResource
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisCenteredZero(axisCenteredZero bool) *YAxisConfigBuilder {
+	builder.internal.AxisCenteredZero = &axisCenteredZero
+
+	return builder
+}
+
+// Sets the maximum value for the yAxis
+func (builder *YAxisConfigBuilder) Max(max float32) *YAxisConfigBuilder {
+	builder.internal.Max = &max
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) AxisBorderShow(axisBorderShow bool) *YAxisConfigBuilder {
+	builder.internal.AxisBorderShow = &axisBorderShow
+
+	return builder
+}
+
+func (builder *YAxisConfigBuilder) applyDefaults() {
+}
diff --git a/go/nodegraph/arcoption_builder_gen.go b/go/nodegraph/arcoption_builder_gen.go
new file mode 100644
index 00000000..9f0a0982
--- /dev/null
+++ b/go/nodegraph/arcoption_builder_gen.go
@@ -0,0 +1,57 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package nodegraph
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[ArcOption] = (*ArcOptionBuilder)(nil)
+
+type ArcOptionBuilder struct {
+	internal *ArcOption
+	errors   map[string]cog.BuildErrors
+}
+
+func NewArcOptionBuilder() *ArcOptionBuilder {
+	resource := &ArcOption{}
+	builder := &ArcOptionBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *ArcOptionBuilder) Build() (ArcOption, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("ArcOption", err)...)
+	}
+
+	if len(errs) != 0 {
+		return ArcOption{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Field from which to get the value. Values should be less than 1, representing fraction of a circle.
+func (builder *ArcOptionBuilder) Field(field string) *ArcOptionBuilder {
+	builder.internal.Field = &field
+
+	return builder
+}
+
+// The color of the arc.
+func (builder *ArcOptionBuilder) Color(color string) *ArcOptionBuilder {
+	builder.internal.Color = &color
+
+	return builder
+}
+
+func (builder *ArcOptionBuilder) applyDefaults() {
+}
diff --git a/go/nodegraph/edgeoptions_builder_gen.go b/go/nodegraph/edgeoptions_builder_gen.go
new file mode 100644
index 00000000..2c6dec59
--- /dev/null
+++ b/go/nodegraph/edgeoptions_builder_gen.go
@@ -0,0 +1,57 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package nodegraph
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[EdgeOptions] = (*EdgeOptionsBuilder)(nil)
+
+type EdgeOptionsBuilder struct {
+	internal *EdgeOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewEdgeOptionsBuilder() *EdgeOptionsBuilder {
+	resource := &EdgeOptions{}
+	builder := &EdgeOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *EdgeOptionsBuilder) Build() (EdgeOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("EdgeOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return EdgeOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Unit for the main stat to override what ever is set in the data frame.
+func (builder *EdgeOptionsBuilder) MainStatUnit(mainStatUnit string) *EdgeOptionsBuilder {
+	builder.internal.MainStatUnit = &mainStatUnit
+
+	return builder
+}
+
+// Unit for the secondary stat to override what ever is set in the data frame.
+func (builder *EdgeOptionsBuilder) SecondaryStatUnit(secondaryStatUnit string) *EdgeOptionsBuilder {
+	builder.internal.SecondaryStatUnit = &secondaryStatUnit
+
+	return builder
+}
+
+func (builder *EdgeOptionsBuilder) applyDefaults() {
+}
diff --git a/go/nodegraph/nodeoptions_builder_gen.go b/go/nodegraph/nodeoptions_builder_gen.go
new file mode 100644
index 00000000..87b6e722
--- /dev/null
+++ b/go/nodegraph/nodeoptions_builder_gen.go
@@ -0,0 +1,73 @@
+// Code generated - EDITING IS FUTILE. DO NOT EDIT.
+
+package nodegraph
+
+import (
+	cog "github.com/grafana/grafana-foundation-sdk/go/cog"
+)
+
+var _ cog.Builder[NodeOptions] = (*NodeOptionsBuilder)(nil)
+
+type NodeOptionsBuilder struct {
+	internal *NodeOptions
+	errors   map[string]cog.BuildErrors
+}
+
+func NewNodeOptionsBuilder() *NodeOptionsBuilder {
+	resource := &NodeOptions{}
+	builder := &NodeOptionsBuilder{
+		internal: resource,
+		errors:   make(map[string]cog.BuildErrors),
+	}
+
+	builder.applyDefaults()
+
+	return builder
+}
+
+func (builder *NodeOptionsBuilder) Build() (NodeOptions, error) {
+	var errs cog.BuildErrors
+
+	for _, err := range builder.errors {
+		errs = append(errs, cog.MakeBuildErrors("NodeOptions", err)...)
+	}
+
+	if len(errs) != 0 {
+		return NodeOptions{}, errs
+	}
+
+	return *builder.internal, nil
+}
+
+// Unit for the main stat to override what ever is set in the data frame.
+func (builder *NodeOptionsBuilder) MainStatUnit(mainStatUnit string) *NodeOptionsBuilder {
+	builder.internal.MainStatUnit = &mainStatUnit
+
+	return builder
+}
+
+// Unit for the secondary stat to override what ever is set in the data frame.
+func (builder *NodeOptionsBuilder) SecondaryStatUnit(secondaryStatUnit string) *NodeOptionsBuilder {
+	builder.internal.SecondaryStatUnit = &secondaryStatUnit
+
+	return builder
+}
+
+// Define which fields are shown as part of the node arc (colored circle around the node).
+func (builder *NodeOptionsBuilder) Arcs(arcs []cog.Builder[ArcOption]) *NodeOptionsBuilder {
+	arcsResources := make([]ArcOption, 0, len(arcs))
+	for _, r1 := range arcs {
+		arcsDepth1, err := r1.Build()
+		if err != nil {
+			builder.errors["arcs"] = err.(cog.BuildErrors)
+			return builder
+		}
+		arcsResources = append(arcsResources, arcsDepth1)
+	}
+	builder.internal.Arcs = arcsResources
+
+	return builder
+}
+
+func (builder *NodeOptionsBuilder) applyDefaults() {
+}
diff --git a/go/nodegraph/panel_builder_gen.go b/go/nodegraph/panel_builder_gen.go
index 9899bdde..22c23186 100644
--- a/go/nodegraph/panel_builder_gen.go
+++ b/go/nodegraph/panel_builder_gen.go
@@ -417,20 +417,30 @@ func (builder *PanelBuilder) WithOverride(matcher dashboard.MatcherConfig, prope
 	return builder
 }
 
-func (builder *PanelBuilder) Nodes(nodes NodeOptions) *PanelBuilder {
+func (builder *PanelBuilder) Nodes(nodes cog.Builder[NodeOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Nodes = &nodes
+	nodesResource, err := nodes.Build()
+	if err != nil {
+		builder.errors["options.nodes"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Nodes = &nodesResource
 
 	return builder
 }
 
-func (builder *PanelBuilder) Edges(edges EdgeOptions) *PanelBuilder {
+func (builder *PanelBuilder) Edges(edges cog.Builder[EdgeOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Edges = &edges
+	edgesResource, err := edges.Build()
+	if err != nil {
+		builder.errors["options.edges"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Edges = &edgesResource
 
 	return builder
 }
diff --git a/go/piechart/panel_builder_gen.go b/go/piechart/panel_builder_gen.go
index a487b5fd..4818ebfc 100644
--- a/go/piechart/panel_builder_gen.go
+++ b/go/piechart/panel_builder_gen.go
@@ -478,11 +478,16 @@ func (builder *PanelBuilder) Text(text cog.Builder[common.VizTextDisplayOptions]
 	return builder
 }
 
-func (builder *PanelBuilder) Legend(legend PieChartLegendOptions) *PanelBuilder {
+func (builder *PanelBuilder) Legend(legend cog.Builder[PieChartLegendOptions]) *PanelBuilder {
 	if builder.internal.Options == nil {
 		builder.internal.Options = &Options{}
 	}
-	builder.internal.Options.(*Options).Legend = legend
+	legendResource, err := legend.Build()
+	if err != nil {
+		builder.errors["options.legend"] = err.(cog.BuildErrors)
+		return builder
+	}
+	builder.internal.Options.(*Options).Legend = legendResource
 
 	return builder
 }
diff --git a/go/piechart/piechartlegendoptions_builder_gen.go b/go/piechart/piechartlegendoptions_builder_gen.go
new file mode 100644
index 00000000..9bed3844
--- /dev/null
+++ b/go/piechart/piechart...*[Comment body truncated]*

K-Phoen added 10 commits October 3, 2024 14:06

Lay down the foundation to convert resources to PHP

ff32c02

PoC disjunction support when converting to PHP

dc4cd43

Correctly convert enums in PHP

7a09e49

Handle struct and map conversion

6cb26fd

Rebuild test files

6ddca54

Generate golden files for PHP converter jenny

ea86c1c

Start fixing some phpstan warnings

682babb

Fix some dataquery-related phpstan warnings

208768d

Generate type assertions for panel generic types in PHP converters

e571177

Try to fix phpstan in ci

014cd69

K-Phoen closed this Oct 3, 2024

K-Phoen deleted the php/json-to-code branch October 3, 2024 22:21

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Php/json to code #575

Php/json to code #575

K-Phoen commented Oct 3, 2024

github-actions bot commented Oct 3, 2024

🔎 Changes to `grafana-foundation-sdk@next+cog-v0.0.x`

Php/json to code #575

Php/json to code #575

Conversation

K-Phoen commented Oct 3, 2024

github-actions bot commented Oct 3, 2024

🔎 Changes to grafana-foundation-sdk@next+cog-v0.0.x

🔎 Changes to `grafana-foundation-sdk@next+cog-v0.0.x`