tfschema

Documentation

Index

• Constants
• Variables
• func DiagError(diags diag.Diagnostics) error
• func FormatDuration(d time.Duration) string
• func IsListEncodedObject(s *schema.Schema) bool
• func JSONNotificationPolicyDiffSuppress(k, old, new string, d *schema.ResourceData) bool
• func ParseDuration(v string) (time.Duration, error)
• func SanitizedDashboardJSON(data string, opts ...SanitizeOpt) (string, error)
• func ValidateNotificationPolicyData(i any, k string) (warnings []string, errors []error)
• type CaseInsensitiveString
  • func (s CaseInsensitiveString) Normalize(v any) any
  • func (s CaseInsensitiveString) Schema() *schema.Schema
• type Duration
  • func (d Duration) Normalize(v any) any
  • func (d Duration) Schema() *schema.Schema
• type Enum
  • func (e Enum) Normalize(v any) any
  • func (e Enum) Schema() *schema.Schema
• type Filter
  • func (f Filter) Normalize(v any) any
  • func (f Filter) Schema() *schema.Schema
• type SanitizeOpt
  • func WithDashboardUID(uid string) SanitizeOpt

Constants

const IndependentNotificationPolicyData = "__independent"

When a notification policy is independent, we always set the notification_policy_data to this static sentinel value such that the bucket resource can detect when it's referencing an independent policy.

Variables

var BlackholeAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
}

var Bucket = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"labels": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},

	"notification_policy_slug": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"notification_policy_id": {
		Type:          schema.TypeString,
		ConflictsWith: []string{"notification_policy_data"},
		Optional:      true,
	},
	"team_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"notification_policy_data": {
		Type:             schema.TypeString,
		Optional:         true,
		DiffSuppressFunc: JSONNotificationPolicyDiffSuppress,
		ValidateFunc:     ValidateNotificationPolicyData,
	},
}

var ClassicDashboard = map[string]*schema.Schema{
	"bucket_id": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: []string{"bucket_id", "collection_id"},
	},
	"collection_id": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: []string{"bucket_id", "collection_id"},
	},
	"dashboard_json": {
		Type:             schema.TypeString,
		Required:         true,
		DiffSuppressFunc: classicDashboardJSONDiffSuppress,
	},
}

var Collection = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"team_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"notification_policy_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
}

var Dashboard = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"collection_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"dashboard_json": {
		Type:                  schema.TypeString,
		Required:              true,
		DiffSuppressFunc:      dashboardJSONDiffSuppress,
		DiffSuppressOnRefresh: true,
	},
}

var DataBucket = map[string]*schema.Schema{
	"slug": {
		Type:         schema.TypeString,
		Optional:     true,
		ExactlyOneOf: dataBucketOneOfAddressFields,
	},
	"name": {
		Type:         schema.TypeString,
		Optional:     true,
		ExactlyOneOf: dataBucketOneOfAddressFields,
	},
	"description": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"labels": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
}

var DataCollection = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"name": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"description": {
		Type:     schema.TypeString,
		Computed: true,
	},
}

var DataService = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Required: true,
	},
	"name": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"description": {
		Type:     schema.TypeString,
		Computed: true,
	},
}

var Dataset = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"configuration": {
		Type:     schema.TypeList,
		Required: true,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: datasetConfigurationSchema,
		},
	},
}

var DerivedLabel = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"label_name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"existing_label_policy": Enum{
		Value:    enum.LabelPolicy.ToStrings(),
		Optional: true,
	}.Schema(),
	"metric_label": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Required: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"constructed_label": {
					Type:     schema.TypeList,
					Optional: true,
					MaxItems: 1,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"value_definitions": {
								Type:     schema.TypeList,
								Required: true,
								Elem: &schema.Resource{
									Schema: map[string]*schema.Schema{
										"value": {
											Type:     schema.TypeString,
											Required: true,
										},
										"filters": {
											Type:     schema.TypeList,
											Required: true,
											Elem: &schema.Resource{
												Schema: map[string]*schema.Schema{
													"name": {
														Type:     schema.TypeString,
														Required: true,
													},
													"value_glob": {
														Type:     schema.TypeString,
														Required: true,
													},
												},
											},
										},
									},
								},
							},
						},
					},
				},
				"mapping_label": {
					Type:     schema.TypeList,
					Optional: true,
					MaxItems: 1,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"name_mappings": {
								Type:     schema.TypeList,
								Optional: true,
								Elem: &schema.Resource{
									Schema: map[string]*schema.Schema{
										"source_label": {
											Type:     schema.TypeString,
											Required: true,
										},
										"filters": {
											Type:     schema.TypeList,
											Required: true,
											Elem: &schema.Resource{
												Schema: map[string]*schema.Schema{
													"name": {
														Type:     schema.TypeString,
														Required: true,
													},
													"value_glob": {
														Type:     schema.TypeString,
														Required: true,
													},
												},
											},
										},
										"value_mappings": ValueMappingsSchema,
									},
								},
							},
							"value_mappings": ValueMappingsSchema,
						},
					},
				},
			},
		},
	},
}

var DerivedMetric = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"metric_name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"queries": {
		Type:     schema.TypeList,
		Required: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"selector": {
					Type:     schema.TypeList,
					Optional: true,
					MaxItems: 1,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"labels": {
								Type:     schema.TypeMap,
								Optional: true,
								Elem:     &schema.Schema{Type: schema.TypeString},
							},
						},
					},
				},
				"query": {
					Type:     schema.TypeList,
					Required: true,
					MinItems: 1,
					MaxItems: 1,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"expr": {
								Type:     schema.TypeString,
								Required: true,
							},
							"variables": {
								Type:     schema.TypeList,
								Optional: true,
								Elem: &schema.Resource{
									Schema: map[string]*schema.Schema{
										"name": {
											Type:     schema.TypeString,
											Required: true,
										},
										"default_selector": {
											Type:     schema.TypeString,
											Required: true,
										},
									},
								},
							},
						},
					},
				},
			},
		},
	},
}

var DropRule = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"active": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  false,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"query": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		MinItems: 1,
		Required: true,
	},
	"conditional_drop": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"drop_nan_value": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"activated_drop_duration": Duration{
		Optional: true,
	}.Schema(),
	"rate_limit_threshold": {
		Type:             schema.TypeFloat,
		Optional:         true,
		ValidateDiagFunc: float64RangeValidator(0, 100.0),
	},
	"value_based_drop": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"target_drop_value": {
					Type:     schema.TypeFloat,
					Required: true,
				},
			},
		},
	},
}

var EmailAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"to": {
		Type:     schema.TypeString,
		Required: true,
	},
	"html": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"text": {
		Type:     schema.TypeString,
		Optional: true,
	},
}

var GcpMetricsIntegration = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"service_account": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"client_email": {
					Type:     schema.TypeString,
					Required: true,
				},
			},
		},
		MinItems: 1,
		MaxItems: 1,
	},
	"metric_groups": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"project_id": {
					Type:     schema.TypeString,
					Required: true,
				},
				"prefixes": {
					Type:     schema.TypeList,
					Optional: true,
					Elem:     &schema.Schema{Type: schema.TypeString},
				},
			},
		},
	},
}

var LogAllocationConfig = map[string]*schema.Schema{
	"default_dataset": {
		Type: schema.TypeList,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"allocation": LogAllocationConfigSchema,
			},
			SchemaVersion: 1,
		},
		Required: true,
		MaxItems: 1,
	},
	"dataset_allocation": {
		Type:     schema.TypeList,
		Elem:     LogDatasetAllocationSchema,
		Optional: true,
		MaxItems: maxAllocations,
	},
}

var LogAllocationConfigSchema = &schema.Schema{
	Type: schema.TypeList,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"percent_of_license": {
				Type:     schema.TypeFloat,
				Required: true,
			},
		},
	},
	MaxItems: 1,
	Required: true,
}

var LogDatasetAllocationSchema = &schema.Resource{
	Schema: map[string]*schema.Schema{
		"dataset_slug": {
			Type:     schema.TypeString,
			Required: true,
		},
		"allocation": LogAllocationConfigSchema,
	},
}

var LogscaleAction = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"repository": {
		Type:     schema.TypeString,
		Required: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"email_action":              LogscaleEmailActionSchema,
	"humio_action":              LogscaleHumioRepoActionSchema,
	"ops_genie_action":          LogscaleOpsGenieActionSchema,
	"pager_duty_action":         LogscalePagerDutyActionSchema,
	"slack_action":              LogscaleSlackActionSchema,
	"slack_post_message_action": LogscaleSlackPostMessageActionSchema,
	"victor_ops_action":         LogscaleVictorOpsActionSchema,
	"webhook_action":            LogscaleWebhookActionSchema,
	"upload_file_action":        LogscaleUploadFileActionSchema,
}

var LogscaleAlert = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"repository": {
		Type:     schema.TypeString,
		Required: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"alert_type": Enum{
		Value:    enum.LogscaleAlertType.ToStrings(),
		Required: true,
	}.Schema(),
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"disabled": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"query": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"time_window": durationWithDescription(Duration{
		Optional: true,
	}, "Required for STANDARD type alerts, ignored for FILTER type alerts"),
	"throttle_duration": durationWithDescription(Duration{
		Optional: true,
	}, "Required for STANDARD type alerts, optional for FILTER type alerts"),
	"throttle_field": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"action_ids": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		Optional: true,
		MinItems: 0,
	},
	"tags": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		Optional: true,
		MinItems: 0,
	},
	"run_as_user": {
		Type:        schema.TypeString,
		Required:    true,
		Description: "Email of the user that the alert runs on behalf of",
	},
}

var LogscaleEmailActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"recipients": {
				Type: schema.TypeList,
				Elem: &schema.Schema{
					Type: schema.TypeString,
				},
				MinItems: 1,
				Required: true,
			},
			"subject_template": {
				Type:     schema.TypeString,
				Optional: true,
			},
			"body_template": {
				Type:     schema.TypeString,
				Optional: true,
			},
			"attach_csv": {
				Type:     schema.TypeBool,
				Optional: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscaleHumioRepoActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"ingest_token": {
				Type:     schema.TypeString,
				Required: true,
			},
		},
	},
}

var LogscaleOpsGenieActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"api_url": {
				Type:     schema.TypeString,
				Required: true,
			},
			"ops_genie_key": {
				Type:     schema.TypeString,
				Required: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscalePagerDutyActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"severity": Enum{
				Value:    enum.LogScalePagerDutyActionSeverity.ToStrings(),
				Required: true,
			}.Schema(),
			"routing_key": {
				Type:     schema.TypeString,
				Required: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscaleSlackActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"url": {
				Type:     schema.TypeString,
				Required: true,
			},
			"fields": {
				Type:     schema.TypeMap,
				Elem:     &schema.Schema{Type: schema.TypeString},
				Optional: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscaleSlackPostMessageActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"api_token": {
				Type:     schema.TypeString,
				Required: true,
			},
			"channels": {
				Type:     schema.TypeList,
				Elem:     &schema.Schema{Type: schema.TypeString},
				MinItems: 1,
				Required: true,
			},
			"fields": {
				Type:     schema.TypeMap,
				Elem:     &schema.Schema{Type: schema.TypeString},
				Optional: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscaleUploadFileActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"file_name": {
				Type:     schema.TypeString,
				Required: true,
			},
		},
	},
}

var LogscaleVictorOpsActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"message_type": {
				Type:     schema.TypeString,
				Required: true,
			},
			"notify_url": {
				Type:     schema.TypeString,
				Required: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var LogscaleWebhookActionSchema = &schema.Schema{
	Type:         schema.TypeList,
	Optional:     true,
	MinItems:     0,
	MaxItems:     1,
	ExactlyOneOf: actionFields,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"method": Enum{
				Value:    enum.LogScaleWebhookActionHTTPMethod.ToStrings(),
				Required: true,
			}.Schema(),
			"url": {
				Type:     schema.TypeString,
				Required: true,
			},
			"headers": {
				Type:     schema.TypeMap,
				Elem:     &schema.Schema{Type: schema.TypeString},
				Optional: true,
			},
			"body_template": {
				Type:     schema.TypeString,
				Optional: true,
			},
			"ignore_ssl": {
				Type:     schema.TypeBool,
				Optional: true,
			},
			"use_proxy": {
				Type:     schema.TypeBool,
				Optional: true,
			},
		},
	},
}

var MappingRule = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"bucket_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"filter": Filter{
		KVDelimiter: aggregationfilter.MappingRuleDelimiter,
	}.Schema(),
	"aggregations": {
		Type:     schema.TypeList,
		Optional: true,
		MaxItems: 1,
		Elem: Enum{
			Value: enum.AggregationType.ToStrings(),
		}.Schema(),
	},

	"storage_policy": {
		Type:     schema.TypeList,
		Optional: true,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"resolution": Duration{
					Required: true,
				}.Schema(),
				"retention": Duration{
					Required: true,
				}.Schema(),
			},
		},
		Deprecated: "use `interval` instead",
	},
	"drop": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  false,
	},

	"drop_timestamp": {
		Type:       schema.TypeBool,
		Optional:   true,
		Default:    false,
		Deprecated: "drop timestamp is no longer supported",
	},
	"interval": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"mode": Enum{
		Value:    enum.MappingModeType.ToStrings(),
		Optional: true,
	}.Schema(),
}

var MatcherListSchema = &schema.Schema{
	Type:     schema.TypeList,
	Required: true,
	MinItems: 1,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"name": {
				Type:     schema.TypeString,
				Required: true,
			},
			"type": Enum{
				Value:    enum.MatcherType.ToStrings(),
				Required: true,
			}.Schema(),
			"value": {
				Type:     schema.TypeString,
				Required: true,
			},
		},
	},
}

var Monitor = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"bucket_id": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: []string{"bucket_id", "collection_id"},
	},
	"collection_id": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: []string{"bucket_id", "collection_id"},
	},
	"notification_policy_id": {
		Type:     schema.TypeString,
		Optional: true,
		ValidateDiagFunc: func(policyID any, _ cty.Path) diag.Diagnostics {
			if localid.IsLocalID(policyID.(string)) {
				return diag.Errorf("cannot directly reference unowned notification policy, use a notifcation policy with team_id set")
			}
			return nil
		},
	},
	"labels": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"annotations": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"query": {
		Type:     schema.TypeList,
		Required: true,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"prometheus_expr": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"graphite_expr": {
					Type:     schema.TypeString,
					Optional: true,
				},
			},
		},
	},
	"signal_grouping": {
		Type:     schema.TypeList,
		Optional: true,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"label_names": {
					Type: schema.TypeList,
					Elem: &schema.Schema{
						Type: schema.TypeString,
					},
					Optional: true,
				},
				"signal_per_series": {
					Type:     schema.TypeBool,
					Optional: true,
				},
			},
		},
	},
	"series_conditions": {
		Type:     schema.TypeList,
		Required: true,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"condition": MonitorSeriesConditionSchema,
				"override": {
					Type:     schema.TypeList,
					Optional: true,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"label_matcher": MatcherListSchema,
							"condition":     MonitorSeriesConditionSchema,
						},
					},
				},
			},
		},
	},
	"interval": Duration{
		Optional: true,
	}.Schema(),
	"schedule": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"timezone": {
					Type:     schema.TypeString,
					Required: true,
				},
				"range": typeset.Set{
					ElemFields: map[string]typeset.ElemField{
						"day": CaseInsensitiveString{
							Required: true,
						},
						"start": typeset.NotNormalized(&schema.Schema{
							Type:     schema.TypeString,
							Required: true,
						}),
						"end": typeset.NotNormalized(&schema.Schema{
							Type:     schema.TypeString,
							Required: true,
						}),
					},
				}.Schema(),
			},
		},
	},
}

var MonitorSeriesConditionSchema = typeset.Set{
	Required: true,
	MinItems: 1,
	ElemFields: map[string]typeset.ElemField{

		"severity": typeset.NotNormalized(&schema.Schema{
			Type:     schema.TypeString,
			Required: true,
		}),
		"op": Enum{
			Value:    enum.ConditionOp.ToStrings(),
			Required: true,
		},
		"value": typeset.NotNormalized(&schema.Schema{
			Type:     schema.TypeFloat,
			Optional: true,
			Default:  0,
		}),
		"sustain": Duration{
			Optional: true,
		},
		"resolve_sustain": Duration{
			Optional: true,
		},
	},
}.Schema()

var NotificationPolicy = map[string]*schema.Schema{

	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Optional: true,
	},

	"team_id": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"name"},
	},
	"route": NotificationRouteSchema,
	"override": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"alert_label_matcher": MatcherListSchema,
				"route":               NotificationRouteSchema,
			},
		},
	},
	"notification_policy_data": {
		Type:             schema.TypeString,
		Optional:         true,
		Computed:         true,
		DiffSuppressFunc: JSONNotificationPolicyDiffSuppress,
		ValidateFunc:     ValidateNotificationPolicyData,
	},

	"is_independent": {
		Type:     schema.TypeBool,
		Computed: true,
		ForceNew: true,
	},
}

var NotificationRouteSchema = typeset.Set{
	ElemFields: map[string]typeset.ElemField{

		"severity": typeset.NotNormalized(&schema.Schema{
			Type:     schema.TypeString,
			Required: true,
		}),
		"notifiers": typeset.NotNormalized(&schema.Schema{
			Type:     schema.TypeSet,
			Optional: true,
			Elem:     &schema.Schema{Type: schema.TypeString},
		}),
		"repeat_interval": Duration{
			Optional: true,
		},
		"group_by": typeset.NotNormalized(&schema.Schema{
			Type:     schema.TypeList,
			MaxItems: 1,
			Optional: true,
			Elem: &schema.Resource{
				Schema: map[string]*schema.Schema{
					"label_names": {
						Type:     schema.TypeList,
						Optional: true,
						Elem:     &schema.Schema{Type: schema.TypeString},
					},
				},
			},
		}),
	},
}.Schema()

var OpsgenieAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"api_key": {
		Type:      schema.TypeString,
		Required:  true,
		Sensitive: true,
	},
	"api_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"message": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"source": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"details": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"responder": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"id": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"name": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"username": {
					Type:     schema.TypeString,
					Optional: true,
				},

				"type": {
					Type:     schema.TypeString,
					Required: true,
				},
			},
		},
	},
	"tags": {
		Type: schema.TypeSet,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		Optional: true,
	},
	"note": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"priority": {
		Type:     schema.TypeString,
		Optional: true,
	},

	"basic_auth_username": {
		Type:          schema.TypeString,
		Optional:      true,
		RequiredWith:  []string{"basic_auth_password"},
		ConflictsWith: []string{"bearer_token"},
	},
	"basic_auth_password": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"basic_auth_password"},
		Sensitive:    true,
	},
	"bearer_token": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"basic_auth_username"},
	},
	"proxy_url": {
		Type:       schema.TypeString,
		Optional:   true,
		Deprecated: "custom proxy URLs are not supported",
	},
	"tls_insecure_skip_verify": {
		Type:     schema.TypeBool,
		Optional: true,
	},
}

var OtelMetricsIngestion = map[string]*schema.Schema{
	"resource_attributes": {
		Type:     schema.TypeList,
		Optional: true,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"flatten_mode": Enum{
					Value:    enum.ResourceAttributesFlattenMode.ToStrings(),
					Optional: true,
				}.Schema(),
				"filter_mode": Enum{
					Value:    enum.ResourceAttributesFilterMode.ToStrings(),
					Optional: true,
				}.Schema(),
				"exclude_keys": {
					Type:     schema.TypeList,
					Optional: true,
					Elem: &schema.Schema{
						Type: schema.TypeString,
					},
				},
				"generate_target_info": {
					Type:     schema.TypeBool,
					Optional: true,
				},
			},
		},
	},
}

var PagerdutyAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"class": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"client": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"client_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"component": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"details": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"group": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"basic_auth_username": {
		Type:          schema.TypeString,
		Optional:      true,
		RequiredWith:  []string{"basic_auth_password"},
		ConflictsWith: []string{"bearer_token"},
	},
	"basic_auth_password": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"basic_auth_password"},
		Sensitive:    true,
	},
	"bearer_token": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"basic_auth_username"},
	},
	"proxy_url": {
		Type:       schema.TypeString,
		Optional:   true,
		Deprecated: "custom proxy URLs are not supported",
	},
	"tls_insecure_skip_verify": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"image": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"alt": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"href": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"src": {
					Type:     schema.TypeString,
					Required: true,
				},
			},
		},
	},
	"link": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"href": {
					Type:     schema.TypeString,
					Required: true,
				},
				"text": {
					Type:     schema.TypeString,
					Optional: true,
				},
			},
		},
	},
	"routing_key": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"service_key": {
		Type:      schema.TypeString,
		Optional:  true,
		Sensitive: true,
	},
	"severity": {
		Type:     schema.TypeString,
		Required: true,
	},
	"url": {
		Type:     schema.TypeString,
		Required: true,
	},
}

var RecordingRule = map[string]*schema.Schema{
	"bucket_id": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: executionGroupFields,
	},
	"execution_group": {
		Type:         schema.TypeString,
		Optional:     true,
		AtLeastOneOf: executionGroupFields,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"labels": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"interval": Duration{
		Optional: true,
	}.Schema(),
	"expr": {
		Type:     schema.TypeString,
		Required: true,
	},
	"metric_name": {
		Type:     schema.TypeString,
		Optional: true,
	},
}

var ResourcePoolAllocationSchema = &schema.Schema{
	Type: schema.TypeList,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"percent_of_license": {
				Type:     schema.TypeFloat,
				Required: true,
			},
		},
	},
	MaxItems: 1,
	Required: true,
}

var ResourcePoolElemSchema = &schema.Resource{
	Schema: map[string]*schema.Schema{
		"name": {
			Type:     schema.TypeString,
			Required: true,
		},
		"allocation": ResourcePoolAllocationSchema,
		"match_rule": {
			Type:       schema.TypeString,
			Optional:   true,
			Deprecated: "use match_rules",
		},
		"match_rules": {
			Type:     schema.TypeList,
			Elem:     &schema.Schema{Type: schema.TypeString},
			MinItems: 1,
			Optional: true,
		},
		"priorities": ResourcePoolPrioritiesSchema,
	},
}

var ResourcePoolPrioritiesSchema = &schema.Schema{
	Type: schema.TypeList,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"high_priority_match_rules": {
				Type:     schema.TypeList,
				Elem:     &schema.Schema{Type: schema.TypeString},
				MinItems: 1,
				Optional: true,
			},
			"low_priority_match_rules": {
				Type:     schema.TypeList,
				Elem:     &schema.Schema{Type: schema.TypeString},
				MinItems: 1,
				Optional: true,
			},
		},
	},
	MaxItems: 1,
	Optional: true,
}

var ResourcePoolsConfig = map[string]*schema.Schema{
	"default_pool": {
		Type: schema.TypeList,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"allocation": ResourcePoolAllocationSchema,
				"priorities": ResourcePoolPrioritiesSchema,
			},
			SchemaVersion: 1,
		},
		Required: true,
		MaxItems: 1,
	},
	"pools": {
		Type:          schema.TypeList,
		Elem:          ResourcePoolElemSchema,
		Optional:      true,
		ConflictsWith: []string{"pool"},
		Deprecated:    "Use pool instead of pools",
		MaxItems:      maxResourcePools,
	},
	"pool": {
		Type:          schema.TypeList,
		Elem:          ResourcePoolElemSchema,
		ConflictsWith: []string{"pools"},
		Optional:      true,
		MaxItems:      maxResourcePools,
	},
}

var RollupRule = map[string]*schema.Schema{
	"bucket_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type: schema.TypeString,

		Required: true,
		ForceNew: true,
	},
	"filter": Filter{
		KVDelimiter: aggregationfilter.RollupRuleDelimiter,
	}.Schema(),
	"new_metric": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"metric_type": Enum{
		Value:    enum.MetricType.ToStrings(),
		Required: true,
	}.Schema(),
	"aggregation": Enum{
		Value:    enum.AggregationType.ToStrings(),
		Optional: true,
	}.Schema(),
	"storage_policies": {
		Type:     schema.TypeList,
		Optional: true,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"resolution": Duration{
					Required: true,
				}.Schema(),
				"retention": Duration{
					Required: true,
				}.Schema(),
			},
		},

		Computed:   true,
		Deprecated: "use `interval` instead",
	},
	"interval": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"storage_policies"},
	},
	"group_by": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
	},
	"exclude_by": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
	},
	"metric_type_tag": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  false,
	},
	"drop_raw": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  false,
	},
	"permissive": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  false,
	},
	"mode": Enum{
		Value:    enum.RollupModeType.ToStrings(),
		Optional: true,
	}.Schema(),
	"graphite_label_policy": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"replace": {
					Type:     schema.TypeList,
					Optional: true,
					Elem: &schema.Resource{
						Schema: map[string]*schema.Schema{
							"name": {
								Type:     schema.TypeString,
								Required: true,
							},
							"new_value": {
								Type:     schema.TypeString,
								Required: true,
							},
						},
					},
				},
			},
		},
	},
}

var SampleRateSchema = &schema.Schema{
	Type:             schema.TypeFloat,
	Required:         true,
	ValidateDiagFunc: float64RangeValidator(0, 1.0),
}

var ServiceAccount = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
		ForceNew: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"email": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"token": {
		Type:      schema.TypeString,
		Computed:  true,
		Sensitive: true,
	},
	"unrestricted": {
		Type:         schema.TypeBool,
		Optional:     true,
		ForceNew:     true,
		ExactlyOneOf: serviceAccountPermOneOfFields,
	},
	"restriction": {
		Type:     schema.TypeList,
		Optional: true,
		ForceNew: true,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"permission": Enum{
					Value:    enum.Permission.ToStrings(),
					Required: true,
				}.Schema(),
				"labels": {
					Type:     schema.TypeMap,
					Elem:     &schema.Schema{Type: schema.TypeString},
					Optional: true,
				},
			},
		},
		ExactlyOneOf: serviceAccountPermOneOfFields,
	},
}

var SlackAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"action": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"name": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"style": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"text": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"type": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"url": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"value": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"action_confirm_text": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"action_confirm_tile": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"action_confirm_ok_text": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"action_confirm_dismiss_text": {
					Type:     schema.TypeString,
					Optional: true,
				},
			},
		},
	},
	"api_url": {
		Type:      schema.TypeString,
		Required:  true,
		Sensitive: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"callback_id": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"channel": {
		Type:     schema.TypeString,
		Required: true,
	},
	"color": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"fallback": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"fields": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"title": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"value": {
					Type:     schema.TypeString,
					Optional: true,
				},
				"short": {
					Type:     schema.TypeBool,
					Optional: true,
				},
			},
		},
	},
	"footer": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"basic_auth_username": {
		Type:          schema.TypeString,
		Optional:      true,
		RequiredWith:  []string{"basic_auth_password"},
		ConflictsWith: []string{"bearer_token"},
	},
	"basic_auth_password": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"basic_auth_password"},
		Sensitive:    true,
	},
	"bearer_token": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"basic_auth_username"},
	},
	"proxy_url": {
		Type:       schema.TypeString,
		Optional:   true,
		Deprecated: "custom proxy URLs are not supported",
	},
	"tls_insecure_skip_verify": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"icon_emoji": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"icon_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"image_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"link_names": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"mrkdwn_in": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
	},
	"pretext": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"short_fields": {
		Type:     schema.TypeBool,
		Optional: true,
	},
	"text": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"thumb_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"title": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"title_link": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"username": {
		Type:     schema.TypeString,
		Optional: true,
	},
}

var Team = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"description": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"user_emails": {
		Type: schema.TypeSet,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		Optional: true,
	},
}

var TestResource = map[string]*schema.Schema{
	"some_string": {
		Type: schema.TypeString,
	},
	"some_bool": {
		Type: schema.TypeBool,
	},
	"some_float": {
		Type: schema.TypeFloat,
	},
	"some_int": {
		Type: schema.TypeInt,
	},
	"some_string_list": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
	},
	"some_object_set": {
		Type: schema.TypeSet,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"inner_string": {
					Type: schema.TypeString,
				},
				"inner_bool": {
					Type: schema.TypeBool,
				},
			},
		},
	},
	"some_string_map": {
		Type: schema.TypeMap,
		Elem: &schema.Schema{Type: schema.TypeString},
	},
	"some_object": {
		Type:     schema.TypeList,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"inner_string": {
					Type: schema.TypeString,
				},
				"inner_bool": {
					Type: schema.TypeBool,
				},
			},
		},
	},
	"optional_object": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"inner_string_list": {
					Type: schema.TypeList,
					Elem: &schema.Schema{
						Type: schema.TypeString,
					},
				},
			},
		},
	},
	"optional_string_list": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeString,
		},
		Optional: true,
	},
	"collection_id": {
		Type: schema.TypeString,
	},

	"notifiers": NotificationRouteSchema.Elem.(*schema.Resource).Schema["notifiers"],

	"optional_bool_with_default": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"computed_and_not_optional": {
		Type:     schema.TypeString,
		Computed: true,
	},
	"computed_and_optional": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
	},
	"dashboard_json": {
		Type: schema.TypeString,
	},
}

TestResource is used exclusively for unit testing.

var TraceBoolFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	MinItems: 0,
	MaxItems: 1,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"value": {
				Type:     schema.TypeBool,
				Required: true,
			},
		},
	},
}

var TraceDurationFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	MaxItems: 1,
	Optional: true,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"min_secs": {
				Type:     schema.TypeFloat,
				Optional: true,
				Default:  0.0,
			},
			"min_seconds": {
				Type:       schema.TypeFloat,
				Optional:   true,
				Default:    0.0,
				Deprecated: "use min_secs instead",
			},
			"max_secs": {
				Type:     schema.TypeFloat,
				Optional: true,
			},
			"max_seconds": {
				Type:       schema.TypeFloat,
				Optional:   true,
				Default:    0.0,
				Deprecated: "use max_secs instead",
			},
		},
	},
}

var TraceFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	MinItems: 0,
	MaxItems: 1,
	Optional: true,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"duration": TraceDurationFilterSchema,
			"error":    TraceBoolFilterSchema,
		},
	},
}

var TraceJaegerRemoteSamplingStrategy = map[string]*schema.Schema{
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"service_name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"applied_strategy": {
		Type:     schema.TypeList,
		Required: true,
		MinItems: 1,
		MaxItems: 1,
		Elem: &schema.Resource{
			Schema: appliedStrategySchema,
		},
	},
}

var TraceMetricsRule = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"metric_name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"metric_labels": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"histogram_buckets_seconds": {
		Type: schema.TypeList,
		Elem: &schema.Schema{
			Type: schema.TypeFloat,
		},
		Optional: true,
	},
	"trace_filter": TraceSearchFilterSchema,
	"group_by": {
		Type:     schema.TypeList,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"key": {
					Type:     schema.TypeList,
					MinItems: 1,
					MaxItems: 1,
					Required: true,
					Elem:     traceMetricsRuleGroupByKeySchema,
				},
				"label": {
					Type:     schema.TypeString,
					Required: true,
				},
			},
		},
	},
}

var TraceNumericFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	MinItems: 0,
	MaxItems: 1,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"comparison": Enum{
				Value:    enum.NumericFilterComparisonType.ToStrings(),
				Required: true,
			}.Schema(),
			"value": {
				Type:     schema.TypeFloat,
				Required: true,
			},
		},
	},
}

var TraceSearchFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	MinItems: 1,
	MaxItems: 1,
	Required: true,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"trace": TraceFilterSchema,
			"span":  TraceSpanFilterListSchema,
		},
	},
}

var TraceSpanCountFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	MinItems: 0,
	MaxItems: 1,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"min": {
				Type:     schema.TypeInt,
				Optional: true,
				Default:  0,
			},
			"max": {
				Type:     schema.TypeInt,
				Optional: true,
				Default:  0,
			},
		},
	},
}

var TraceSpanFilterListSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"match_type": {
				Type:             schema.TypeString,
				Optional:         true,
				Default:          prettyenum.SpanFilterMatchTypeInclude,
				ValidateDiagFunc: validateSpanFilterMatchType,
				DiffSuppressFunc: diffSuppressSpanFilterMatchType,
			},
			"service":          TraceStringFilterSchema,
			"operation":        TraceStringFilterSchema,
			"parent_service":   TraceStringFilterSchema,
			"parent_operation": TraceStringFilterSchema,
			"duration":         TraceDurationFilterSchema,
			"error":            TraceBoolFilterSchema,

			"tag":        TraceTagFilterSchema,
			"tags":       deprecated(TraceTagFilterSchema, "`tags` is deprecated, use `tag` instead."),
			"span_count": TraceSpanCountFilterSchema,
		},
	},
}

var TraceStringFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	MinItems: 0,
	MaxItems: 1,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"match": {
				Type:             schema.TypeString,
				Optional:         true,
				Default:          prettyenum.StringFilterMatchTypeExact,
				ValidateDiagFunc: validateStringFilterMatchType,
				DiffSuppressFunc: diffSuppressStringFilterMatchType,
			},
			"value": {
				Type:     schema.TypeString,
				Optional: true,
			},
			"in_values": {
				Type:     schema.TypeList,
				Optional: true,
				MinItems: 0,
				Elem:     &schema.Schema{Type: schema.TypeString},
			},
		},
	},
}

var TraceTagFilterSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	Elem:     traceTagFilterItemSchema,
}

var TraceTailSamplingRules = map[string]*schema.Schema{
	"default_sample_rate": {
		Type:     schema.TypeList,
		MaxItems: 1,
		Optional: true,
		Elem: &schema.Resource{
			Schema: map[string]*schema.Schema{
				"enabled": {
					Type:     schema.TypeBool,
					Optional: true,
				},
				"sample_rate": SampleRateSchema,
			},
		},
	},
	"rules": rulesSchema,
}

var ValueMappingsSchema = &schema.Schema{
	Type:     schema.TypeList,
	Optional: true,
	Elem: &schema.Resource{
		Schema: map[string]*schema.Schema{
			"target_value": {
				Type:     schema.TypeString,
				Required: true,
			},
			"source_value_globs": {
				Type:     schema.TypeList,
				Required: true,
				Elem:     &schema.Schema{Type: schema.TypeString},
			},
		},
	},
}

var VictoropsAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"api_key": {
		Type:      schema.TypeString,
		Required:  true,
		Sensitive: true,
	},
	"api_url": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"routing_key": {
		Type:     schema.TypeString,
		Required: true,
	},
	"state_message": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"message_type": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"custom_fields": {
		Type:     schema.TypeMap,
		Elem:     &schema.Schema{Type: schema.TypeString},
		Optional: true,
	},
	"monitoring_tool": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"entity_display_name": {
		Type:     schema.TypeString,
		Optional: true,
	},
	"basic_auth_username": {
		Type:          schema.TypeString,
		Optional:      true,
		RequiredWith:  []string{"basic_auth_password"},
		ConflictsWith: []string{"bearer_token"},
	},
	"basic_auth_password": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"basic_auth_password"},
		Sensitive:    true,
	},
	"bearer_token": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"basic_auth_username"},
	},
	"proxy_url": {
		Type:       schema.TypeString,
		Optional:   true,
		Deprecated: "custom proxy URLs are not supported",
	},
	"tls_insecure_skip_verify": {
		Type:     schema.TypeBool,
		Optional: true,
	},
}

var WebhookAlertNotifier = map[string]*schema.Schema{
	"name": {
		Type:     schema.TypeString,
		Required: true,
	},
	"slug": {
		Type:     schema.TypeString,
		Optional: true,
		Computed: true,
		ForceNew: true,
	},
	"send_resolved": {
		Type:     schema.TypeBool,
		Optional: true,
		Default:  true,
	},
	"url": {
		Type:     schema.TypeString,
		Required: true,
	},
	"basic_auth_username": {
		Type:          schema.TypeString,
		Optional:      true,
		RequiredWith:  []string{"basic_auth_password"},
		ConflictsWith: []string{"bearer_token"},
	},
	"basic_auth_password": {
		Type:         schema.TypeString,
		Optional:     true,
		RequiredWith: []string{"basic_auth_password"},
		Sensitive:    true,
	},
	"bearer_token": {
		Type:          schema.TypeString,
		Optional:      true,
		ConflictsWith: []string{"basic_auth_username"},
	},
	"proxy_url": {
		Type:       schema.TypeString,
		Optional:   true,
		Deprecated: "custom proxy URLs are not supported",
	},
	"tls_insecure_skip_verify": {
		Type:     schema.TypeBool,
		Optional: true,
	},
}

Functions

func DiagError

func DiagError(diags diag.Diagnostics) error

func FormatDuration

func FormatDuration(d time.Duration) string

FormatDuration formats a time.Duration based on the prom model.Duration type. This matches the backend parsing logic.

func IsListEncodedObject

func IsListEncodedObject(s *schema.Schema) bool

IsListEncodedObject returns whether s defines a list encoded object.

func JSONNotificationPolicyDiffSuppress

func JSONNotificationPolicyDiffSuppress(k, old, new string, d *schema.ResourceData) bool

JSONNotificationPolicyDiffSuppress returns true if the diff between old and new notification policy JSON values should be suppressed, i.e. the resources are not considered different.

func ParseDuration

func ParseDuration(v string) (time.Duration, error)

ParseDuration parses a time.Duration string based on the prom model.Duration type. This matches the backend parsing logic.

func SanitizedDashboardJSON

func SanitizedDashboardJSON(data string, opts ...SanitizeOpt) (string, error)

SanitizedDashboardJSON sanitizes a dashboard JSON payload, clearing fields irrelevant to reading or upserting dashboards.

func ValidateNotificationPolicyData

func ValidateNotificationPolicyData(i any, k string) (warnings []string, errors []error)

ValidateNotificationPolicyData is a SchemaValidateFunc which tests if the provided value is of type string and is valid JSON. It does not validate that it is a serialization of a notification policy but we control that in the provider so we know what we're passing in is safe. If for some reason some valid but incorrect JSON does get set then this will fail on apply

TODO: fix the code so that valid, but incorrect JSON for a notification policy fails on plan

Types

type CaseInsensitiveString

type CaseInsensitiveString struct {
	Required bool
}

CaseInsensitiveString defines the parameters of a case-insensitive string field in a Terraform schema.

func (CaseInsensitiveString) Normalize

func (s CaseInsensitiveString) Normalize(v any) any

Normalize implements typeset.Normalizer.

func (CaseInsensitiveString) Schema

func (s CaseInsensitiveString) Schema() *schema.Schema

Schema returns the Terraform schema of the string.

type Duration

type Duration struct {
	Required bool
	Optional bool
}

Duration defines the parameters of a duration field in a Terraform schema.

func (Duration) Normalize

func (d Duration) Normalize(v any) any

Normalize implements typeset.Normalizer.

func (Duration) Schema

func (d Duration) Schema() *schema.Schema

Schema returns the Terraform schema of the duration.

type Enum

type Enum struct {
	Value    enum.Enum[string]
	Required bool
	Optional bool
	ForceNew bool
}

Enum defines the parameters of an enum field in a Terraform schema.

func (Enum) Normalize

func (e Enum) Normalize(v any) any

Normalize implements typeset.Normalizer.

func (Enum) Schema

func (e Enum) Schema() *schema.Schema

Schema returns the Terraform of the enum.

type Filter

type Filter struct {
	KVDelimiter string
}

Filter represents a raw string glob label filter, where label-value pairs are delimited by the given KVDelimiter. E.g. "__name__:foo instace:service*" (where KVDelimiter=":").

This requires a normalized schema because the original whitespace is not persisted in the server-side database (e.g. a filter with multiple consecutive spaces would always produce a diff).

func (Filter) Normalize

func (f Filter) Normalize(v any) any

func (Filter) Schema

func (f Filter) Schema() *schema.Schema

type SanitizeOpt

type SanitizeOpt func(map[string]any) error

SanitizeOpt is an option passed to SanitizedDashboardJSON.

func WithDashboardUID

func WithDashboardUID(uid string) SanitizeOpt

WithDashboardUID sets or clears the dashboard `uid` field. If uid is given, the `uid` field is set to it in the JSON payload. Otherwise, the payload omits the `uid` field.