Regenerate client from commit 53a6366 of spec repo (#3736)

Co-authored-by: ci.datadog-api-spec <packages@datadoghq.com>

Author: api-clients-generation-pipeline[bot]

.generator/schemas/v1/openapi.yaml

@@ -12338,33 +12338,73 @@ components:
       type: object
     SLOCountDefinition:
       description: 'A count-based (metric) SLI specification, composed of three parts:
-        the good events formula, the total events formula,
+        the good events formula,
 
-        and the underlying queries.'
+        the bad or total events formula, and the underlying queries.
+
+        Exactly one of `total_events_formula` or `bad_events_formula` must be provided.'
       example:
-        good_events_formula: query1 - query2
+        bad_events_formula: query2
+        good_events_formula: query1
         queries:
         - data_source: metrics
           name: query1
-          query: sum:trace.servlet.request.hits{*} by {env}.as_count()
+          query: sum:trace.servlet.request.hits{!http.status_code:500} by {env}.as_count()
         - data_source: metrics
           name: query2
-          query: sum:trace.servlet.request.errors{*} by {env}.as_count()
-        total_events_formula: query1
+          query: sum:trace.servlet.request.hits{http.status_code:500} by {env}.as_count()
+      oneOf:
+      - $ref: '#/components/schemas/SLOCountDefinitionWithTotalEventsFormula'
+      - $ref: '#/components/schemas/SLOCountDefinitionWithBadEventsFormula'
+    SLOCountDefinitionWithBadEventsFormula:
+      additionalProperties: false
       properties:
+        bad_events_formula:
+          $ref: '#/components/schemas/SLOFormula'
+          description: The bad events formula (recommended). Total events queries
+            can be defined using the `total_events_formula` field as an alternative.
+            Only one of `total_events_formula` or `bad_events_formula` must be provided.
         good_events_formula:
           $ref: '#/components/schemas/SLOFormula'
         queries:
           example:
           - data_source: metrics
             name: query1
-            query: sum:trace.servlet.request.hits{*} by {env}.as_count()
+            query: sum:trace.servlet.request.hits{!http.status_code:500} by {env}.as_count()
+          - data_source: metrics
+            name: query2
+            query: sum:trace.servlet.request.hits{http.status_code:500} by {env}.as_count()
+          items:
+            $ref: '#/components/schemas/SLODataSourceQueryDefinition'
+          minItems: 1
+          type: array
+      required:
+      - good_events_formula
+      - bad_events_formula
+      - queries
+      type: object
+    SLOCountDefinitionWithTotalEventsFormula:
+      additionalProperties: false
+      properties:
+        good_events_formula:
+          $ref: '#/components/schemas/SLOFormula'
+        queries:
+          example:
+          - data_source: metrics
+            name: query1
+            query: sum:trace.servlet.request.hits{!http.status_code:500} by {env}.as_count()
+          - data_source: metrics
+            name: query2
+            query: sum:trace.servlet.request.hits{http.status_code:500} by {env}.as_count()
           items:
             $ref: '#/components/schemas/SLODataSourceQueryDefinition'
           minItems: 1
           type: array
         total_events_formula:
           $ref: '#/components/schemas/SLOFormula'
+          description: The total events formula. Bad events queries can be defined
+            using the `bad_events_formula` field as an alternative. Only one of `total_events_formula`
+            or `bad_events_formula` must be provided.
       required:
       - good_events_formula
       - total_events_formula
@@ -12375,15 +12415,15 @@ components:
       description: A metric SLI specification.
       example:
         count:
-          good_events_formula: query1 - query2
+          bad_events_formula: query2
+          good_events_formula: query1
           queries:
           - data_source: metrics
             name: query1
-            query: sum:trace.servlet.request.hits{*} by {env}.as_count()
+            query: sum:trace.servlet.request.hits{!http.status_code:500} by {env}.as_count()
           - data_source: metrics
             name: query2
-            query: sum:trace.servlet.request.errors{*} by {env}.as_count()
-          total_events_formula: query1
+            query: sum:trace.servlet.request.hits{http.status_code:500} by {env}.as_count()
       properties:
         count:
           $ref: '#/components/schemas/SLOCountDefinition'
@@ -13519,7 +13559,7 @@ components:
               name: query1
               query: sum:trace.servlet.request.hits{*} by {env}.as_count()
             - data_source: metrics
-              name: query1
+              name: query2
               query: sum:trace.servlet.request.errors{*} by {env}.as_count()
           threshold: 5
       properties:

api/datadogV1/model_slo_count_definition.go

@@ -5,174 +5,103 @@
 package datadogV1
 
 import (
-	"fmt"
-
 	"github.com/DataDog/datadog-api-client-go/v2/api/datadog"
 )
 
-// SLOCountDefinition A count-based (metric) SLI specification, composed of three parts: the good events formula, the total events formula,
-// and the underlying queries.
+// SLOCountDefinition - A count-based (metric) SLI specification, composed of three parts: the good events formula,
+// the bad or total events formula, and the underlying queries.
+// Exactly one of `total_events_formula` or `bad_events_formula` must be provided.
 type SLOCountDefinition struct {
-	// A formula that specifies how to combine the results of multiple queries.
-	GoodEventsFormula SLOFormula `json:"good_events_formula"`
-	//
-	Queries []SLODataSourceQueryDefinition `json:"queries"`
-	// A formula that specifies how to combine the results of multiple queries.
-	TotalEventsFormula SLOFormula `json:"total_events_formula"`
-	// UnparsedObject contains the raw value of the object if there was an error when deserializing into the struct
-	UnparsedObject       map[string]interface{} `json:"-"`
-	AdditionalProperties map[string]interface{} `json:"-"`
-}
+	SLOCountDefinitionWithTotalEventsFormula *SLOCountDefinitionWithTotalEventsFormula
+	SLOCountDefinitionWithBadEventsFormula   *SLOCountDefinitionWithBadEventsFormula
 
-// NewSLOCountDefinition instantiates a new SLOCountDefinition object.
-// This constructor will assign default values to properties that have it defined,
-// and makes sure properties required by API are set, but the set of arguments
-// will change when the set of required properties is changed.
-func NewSLOCountDefinition(goodEventsFormula SLOFormula, queries []SLODataSourceQueryDefinition, totalEventsFormula SLOFormula) *SLOCountDefinition {
-	this := SLOCountDefinition{}
-	this.GoodEventsFormula = goodEventsFormula
-	this.Queries = queries
-	this.TotalEventsFormula = totalEventsFormula
-	return &this
+	// UnparsedObject contains the raw value of the object if there was an error when deserializing into the struct
+	UnparsedObject interface{}
 }
 
-// NewSLOCountDefinitionWithDefaults instantiates a new SLOCountDefinition object.
-// This constructor will only assign default values to properties that have it defined,
-// but it doesn't guarantee that properties required by API are set.
-func NewSLOCountDefinitionWithDefaults() *SLOCountDefinition {
-	this := SLOCountDefinition{}
-	return &this
+// SLOCountDefinitionWithTotalEventsFormulaAsSLOCountDefinition is a convenience function that returns SLOCountDefinitionWithTotalEventsFormula wrapped in SLOCountDefinition.
+func SLOCountDefinitionWithTotalEventsFormulaAsSLOCountDefinition(v *SLOCountDefinitionWithTotalEventsFormula) SLOCountDefinition {
+	return SLOCountDefinition{SLOCountDefinitionWithTotalEventsFormula: v}
 }
 
-// GetGoodEventsFormula returns the GoodEventsFormula field value.
-func (o *SLOCountDefinition) GetGoodEventsFormula() SLOFormula {
-	if o == nil {
-		var ret SLOFormula
-		return ret
-	}
-	return o.GoodEventsFormula
+// SLOCountDefinitionWithBadEventsFormulaAsSLOCountDefinition is a convenience function that returns SLOCountDefinitionWithBadEventsFormula wrapped in SLOCountDefinition.
+func SLOCountDefinitionWithBadEventsFormulaAsSLOCountDefinition(v *SLOCountDefinitionWithBadEventsFormula) SLOCountDefinition {
+	return SLOCountDefinition{SLOCountDefinitionWithBadEventsFormula: v}
 }
 
-// GetGoodEventsFormulaOk returns a tuple with the GoodEventsFormula field value
-// and a boolean to check if the value has been set.
-func (o *SLOCountDefinition) GetGoodEventsFormulaOk() (*SLOFormula, bool) {
-	if o == nil {
-		return nil, false
+// UnmarshalJSON turns data into one of the pointers in the struct.
+func (obj *SLOCountDefinition) UnmarshalJSON(data []byte) error {
+	var err error
+	match := 0
+	// try to unmarshal data into SLOCountDefinitionWithTotalEventsFormula
+	err = datadog.Unmarshal(data, &obj.SLOCountDefinitionWithTotalEventsFormula)
+	if err == nil {
+		if obj.SLOCountDefinitionWithTotalEventsFormula != nil && obj.SLOCountDefinitionWithTotalEventsFormula.UnparsedObject == nil {
+			jsonSLOCountDefinitionWithTotalEventsFormula, _ := datadog.Marshal(obj.SLOCountDefinitionWithTotalEventsFormula)
+			if string(jsonSLOCountDefinitionWithTotalEventsFormula) == "{}" { // empty struct
+				obj.SLOCountDefinitionWithTotalEventsFormula = nil
+			} else {
+				match++
+			}
+		} else {
+			obj.SLOCountDefinitionWithTotalEventsFormula = nil
+		}
+	} else {
+		obj.SLOCountDefinitionWithTotalEventsFormula = nil
+	}
+
+	// try to unmarshal data into SLOCountDefinitionWithBadEventsFormula
+	err = datadog.Unmarshal(data, &obj.SLOCountDefinitionWithBadEventsFormula)
+	if err == nil {
+		if obj.SLOCountDefinitionWithBadEventsFormula != nil && obj.SLOCountDefinitionWithBadEventsFormula.UnparsedObject == nil {
+			jsonSLOCountDefinitionWithBadEventsFormula, _ := datadog.Marshal(obj.SLOCountDefinitionWithBadEventsFormula)
+			if string(jsonSLOCountDefinitionWithBadEventsFormula) == "{}" { // empty struct
+				obj.SLOCountDefinitionWithBadEventsFormula = nil
+			} else {
+				match++
+			}
+		} else {
+			obj.SLOCountDefinitionWithBadEventsFormula = nil
+		}
+	} else {
+		obj.SLOCountDefinitionWithBadEventsFormula = nil
 	}
-	return &o.GoodEventsFormula, true
-}
 
-// SetGoodEventsFormula sets field value.
-func (o *SLOCountDefinition) SetGoodEventsFormula(v SLOFormula) {
-	o.GoodEventsFormula = v
-}
-
-// GetQueries returns the Queries field value.
-func (o *SLOCountDefinition) GetQueries() []SLODataSourceQueryDefinition {
-	if o == nil {
-		var ret []SLODataSourceQueryDefinition
-		return ret
+	if match != 1 { // more than 1 match
+		// reset to nil
+		obj.SLOCountDefinitionWithTotalEventsFormula = nil
+		obj.SLOCountDefinitionWithBadEventsFormula = nil
+		return datadog.Unmarshal(data, &obj.UnparsedObject)
 	}
-	return o.Queries
+	return nil // exactly one match
 }
 
-// GetQueriesOk returns a tuple with the Queries field value
-// and a boolean to check if the value has been set.
-func (o *SLOCountDefinition) GetQueriesOk() (*[]SLODataSourceQueryDefinition, bool) {
-	if o == nil {
-		return nil, false
+// MarshalJSON turns data from the first non-nil pointers in the struct to JSON.
+func (obj SLOCountDefinition) MarshalJSON() ([]byte, error) {
+	if obj.SLOCountDefinitionWithTotalEventsFormula != nil {
+		return datadog.Marshal(&obj.SLOCountDefinitionWithTotalEventsFormula)
 	}
-	return &o.Queries, true
-}
-
-// SetQueries sets field value.
-func (o *SLOCountDefinition) SetQueries(v []SLODataSourceQueryDefinition) {
-	o.Queries = v
-}
 
-// GetTotalEventsFormula returns the TotalEventsFormula field value.
-func (o *SLOCountDefinition) GetTotalEventsFormula() SLOFormula {
-	if o == nil {
-		var ret SLOFormula
-		return ret
+	if obj.SLOCountDefinitionWithBadEventsFormula != nil {
+		return datadog.Marshal(&obj.SLOCountDefinitionWithBadEventsFormula)
 	}
-	return o.TotalEventsFormula
-}
 
-// GetTotalEventsFormulaOk returns a tuple with the TotalEventsFormula field value
-// and a boolean to check if the value has been set.
-func (o *SLOCountDefinition) GetTotalEventsFormulaOk() (*SLOFormula, bool) {
-	if o == nil {
-		return nil, false
+	if obj.UnparsedObject != nil {
+		return datadog.Marshal(obj.UnparsedObject)
 	}
-	return &o.TotalEventsFormula, true
-}
-
-// SetTotalEventsFormula sets field value.
-func (o *SLOCountDefinition) SetTotalEventsFormula(v SLOFormula) {
-	o.TotalEventsFormula = v
+	return nil, nil // no data in oneOf schemas
 }
 
-// MarshalJSON serializes the struct using spec logic.
-func (o SLOCountDefinition) MarshalJSON() ([]byte, error) {
-	toSerialize := map[string]interface{}{}
-	if o.UnparsedObject != nil {
-		return datadog.Marshal(o.UnparsedObject)
-	}
-	toSerialize["good_events_formula"] = o.GoodEventsFormula
-	toSerialize["queries"] = o.Queries
-	toSerialize["total_events_formula"] = o.TotalEventsFormula
-
-	for key, value := range o.AdditionalProperties {
-		toSerialize[key] = value
-	}
-	return datadog.Marshal(toSerialize)
-}
-
-// UnmarshalJSON deserializes the given payload.
-func (o *SLOCountDefinition) UnmarshalJSON(bytes []byte) (err error) {
-	all := struct {
-		GoodEventsFormula  *SLOFormula                     `json:"good_events_formula"`
-		Queries            *[]SLODataSourceQueryDefinition `json:"queries"`
-		TotalEventsFormula *SLOFormula                     `json:"total_events_formula"`
-	}{}
-	if err = datadog.Unmarshal(bytes, &all); err != nil {
-		return datadog.Unmarshal(bytes, &o.UnparsedObject)
-	}
-	if all.GoodEventsFormula == nil {
-		return fmt.Errorf("required field good_events_formula missing")
-	}
-	if all.Queries == nil {
-		return fmt.Errorf("required field queries missing")
-	}
-	if all.TotalEventsFormula == nil {
-		return fmt.Errorf("required field total_events_formula missing")
-	}
-	additionalProperties := make(map[string]interface{})
-	if err = datadog.Unmarshal(bytes, &additionalProperties); err == nil {
-		datadog.DeleteKeys(additionalProperties, &[]string{"good_events_formula", "queries", "total_events_formula"})
-	} else {
-		return err
-	}
-
-	hasInvalidField := false
-	if all.GoodEventsFormula.UnparsedObject != nil && o.UnparsedObject == nil {
-		hasInvalidField = true
-	}
-	o.GoodEventsFormula = *all.GoodEventsFormula
-	o.Queries = *all.Queries
-	if all.TotalEventsFormula.UnparsedObject != nil && o.UnparsedObject == nil {
-		hasInvalidField = true
-	}
-	o.TotalEventsFormula = *all.TotalEventsFormula
-
-	if len(additionalProperties) > 0 {
-		o.AdditionalProperties = additionalProperties
+// GetActualInstance returns the actual instance.
+func (obj *SLOCountDefinition) GetActualInstance() interface{} {
+	if obj.SLOCountDefinitionWithTotalEventsFormula != nil {
+		return obj.SLOCountDefinitionWithTotalEventsFormula
 	}
 
-	if hasInvalidField {
-		return datadog.Unmarshal(bytes, &o.UnparsedObject)
+	if obj.SLOCountDefinitionWithBadEventsFormula != nil {
+		return obj.SLOCountDefinitionWithBadEventsFormula
 	}
 
+	// all schemas are nil
 	return nil
 }