{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://raw.githubusercontent.com/api-evangelist/chronosphere/main/json-schema/chronosphere-config-v1-update-dataset-body-schema.json",
  "title": "ConfigV1UpdateDatasetBody",
  "x-generated": "2026-10-03",
  "x-method": "derived",
  "x-generator": "derive-json-schema.py",
  "x-source": "openapi/chronosphere-dataset-api-openapi.yml#/components/schemas/ConfigV1UpdateDatasetBody",
  "properties": {
    "create_if_missing": {
      "description": "If `true`, the Dataset will be created if it does not already exist, identified by `slug`. If `false`, an error will be returned if the Dataset does not already exist.",
      "type": "boolean"
    },
    "dataset": {
      "allOf": [
        {
          "$ref": "#/$defs/configv1Dataset"
        }
      ],
      "description": "The Dataset to update."
    },
    "dry_run": {
      "description": "If `true`, validates the specified configuration without creating or updating the Dataset. If the specified configuration is valid, the endpoint returns a partial response without the Dataset. If the specified configuration is invalid, the endpoint returns an error.",
      "type": "boolean"
    }
  },
  "type": "object",
  "$defs": {
    "DatasetDatasetConfiguration": {
      "properties": {
        "log_dataset": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogDataset"
            }
          ],
          "description": "If the dataset type is `LOGS`, this configuration defines the semantics for\nthe log dataset."
        },
        "trace_dataset": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1TraceDataset"
            }
          ],
          "description": "If the dataset type is `TRACES`, this configuration defines the semantics for\nthe trace dataset."
        },
        "type": {
          "allOf": [
            {
              "$ref": "#/$defs/DatasetDatasetType"
            }
          ],
          "description": "The type of dataset."
        }
      },
      "type": "object"
    },
    "DatasetDatasetType": {
      "enum": [
        "TRACES",
        "LOGS"
      ],
      "type": "string"
    },
    "NumericFilterComparisonType": {
      "enum": [
        "EQUAL",
        "NOT_EQUAL",
        "GREATER_THAN",
        "GREATER_THAN_OR_EQUAL",
        "LESS_THAN",
        "LESS_THAN_OR_EQUAL"
      ],
      "type": "string"
    },
    "SpanFilterSpanFilterMatchType": {
      "enum": [
        "INCLUDE",
        "EXCLUDE"
      ],
      "type": "string"
    },
    "StringFilterStringFilterMatchType": {
      "enum": [
        "EXACT",
        "REGEX",
        "EXACT_NEGATION",
        "REGEX_NEGATION",
        "IN",
        "NOT_IN"
      ],
      "type": "string"
    },
    "TraceSearchFilterBoolFilter": {
      "properties": {
        "value": {
          "description": "The value of the filter compared to the target trace or span field.",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterCountFilter": {
      "properties": {
        "max": {
          "description": "Maximum number of spans that must match a span query, inclusive.",
          "format": "int32",
          "type": "integer"
        },
        "min": {
          "description": "Minimum number of spans that must match a span query, inclusive.",
          "format": "int32",
          "type": "integer"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterDurationFilter": {
      "properties": {
        "max_secs": {
          "description": "Maximum duration, in seconds, required for a span or trace to match.",
          "format": "double",
          "type": "number"
        },
        "min_secs": {
          "description": "Minimum duration, in seconds, required for a span or trace to match.",
          "format": "double",
          "type": "number"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterNumericFilter": {
      "properties": {
        "comparison": {
          "allOf": [
            {
              "$ref": "#/$defs/NumericFilterComparisonType"
            }
          ],
          "description": "The comparison operation to apply to an input against the given query value."
        },
        "value": {
          "description": "The filter value used in comparison against match candidates.",
          "format": "double",
          "type": "number"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterScopeFilter": {
      "properties": {
        "span_scopes": {
          "description": "Specifies the span filters that define which spans contribute to the metrics calculation.\nOnly spans matching these filters will be included in the metrics aggregation.",
          "items": {
            "$ref": "#/$defs/TraceSearchFilterSpanFilter"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterSpanFilter": {
      "properties": {
        "duration": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterDurationFilter"
            }
          ],
          "description": "Matches the duration of the candidate span."
        },
        "error": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterBoolFilter"
            }
          ],
          "description": "Matches the error status of the candidate span."
        },
        "is_root_span": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterBoolFilter"
            }
          ],
          "description": "Matches the root span of a trace. For example, if the parent span has no child\nspans."
        },
        "match_type": {
          "allOf": [
            {
              "$ref": "#/$defs/SpanFilterSpanFilterMatchType"
            }
          ],
          "description": "If `INCLUDE`, includes all traces that have at least one (or `span_count`)\nspans matching the query. If `EXCLUDE`, excludes all traces that have at least\none (or `span_count`) spans matching the query."
        },
        "operation": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterStringFilter"
            }
          ],
          "description": "Matches the operation of the candidate span."
        },
        "parent_operation": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterStringFilter"
            }
          ],
          "description": "If not a root span, matches the operation of the candidate span's parent span"
        },
        "parent_service": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterStringFilter"
            }
          ],
          "description": "If not a root span, matches the service of the candidate span's parent span."
        },
        "service": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterStringFilter"
            }
          ],
          "description": "Matches the service of the candidate span."
        },
        "span_count": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterCountFilter"
            }
          ],
          "description": "Defines the number of spans that must match the criteria defined by the span\nquery. Defaults to requiring that at least one span matches the span query."
        },
        "tags": {
          "description": "Matches the tags of the candidate span.",
          "items": {
            "$ref": "#/$defs/TraceSearchFilterTagFilter"
          },
          "type": "array"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterStringFilter": {
      "properties": {
        "in_values": {
          "description": "Values the filter tests against when using `IN` or `NOT_IN` match type.",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "match": {
          "allOf": [
            {
              "$ref": "#/$defs/StringFilterStringFilterMatchType"
            }
          ],
          "description": "Specifies the comparison operator for the query. If `EXACT`, compared strings\nmust have the exact value of the query value."
        },
        "value": {
          "description": "The value of the filter compared to the target trace or span field.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "TraceSearchFilterTagFilter": {
      "properties": {
        "key": {
          "description": "The key or name of the span tag that this filter inspects.",
          "type": "string"
        },
        "numeric_value": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterNumericFilter"
            }
          ],
          "description": "If the query matches the tag with the specified key, and the value type is\n`numeric`, specifies the matcher used to evaluate the span tag value."
        },
        "value": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterStringFilter"
            }
          ],
          "description": "If the query matches the tag with the specified key, and the value type is a\n`string`, specifies the matcher used to evaluate the span tag value."
        }
      },
      "type": "object"
    },
    "TraceSearchFilterTraceFilter": {
      "properties": {
        "duration": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterDurationFilter"
            }
          ],
          "description": "Matches traces based on the duration of the entire trace."
        },
        "error": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterBoolFilter"
            }
          ],
          "description": "Matches traces based on the top-level error status."
        }
      },
      "type": "object"
    },
    "configv1Dataset": {
      "properties": {
        "configuration": {
          "allOf": [
            {
              "$ref": "#/$defs/DatasetDatasetConfiguration"
            }
          ],
          "description": "Required. Defines the configuration of the dataset."
        },
        "created_at": {
          "description": "Timestamp of when the Dataset was created. Cannot be set by clients.",
          "format": "date-time",
          "readOnly": true,
          "type": "string"
        },
        "description": {
          "description": "Required. Description of the dataset.",
          "type": "string"
        },
        "name": {
          "description": "The name of the Dataset. You can modify this value after the Dataset is created.",
          "type": "string"
        },
        "slug": {
          "description": "The unique identifier of the Dataset. If a `slug` isn't provided, one is generated based on the `name` field. You can't modify this field after the Dataset is created.",
          "type": "string"
        },
        "updated_at": {
          "description": "Timestamp of when the Dataset was last updated. Cannot be set by clients.",
          "format": "date-time",
          "readOnly": true,
          "type": "string"
        }
      },
      "required": [
        "name"
      ],
      "type": "object"
    },
    "configv1LogDataset": {
      "properties": {
        "match_criteria": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1LogSearchFilter"
            }
          ],
          "description": "Required. Defines the criteria to match logs to a dataset."
        }
      },
      "type": "object"
    },
    "configv1LogSearchFilter": {
      "properties": {
        "query": {
          "description": "Returns logs that match this query. The query can include only top-level\noperations. Nested clauses aren't supported. Only one type of `AND` or `OR`\noperator is allowed.",
          "type": "string"
        }
      },
      "type": "object"
    },
    "configv1TraceDataset": {
      "properties": {
        "match_criteria": {
          "allOf": [
            {
              "$ref": "#/$defs/configv1TraceSearchFilter"
            }
          ],
          "description": "Required. Defines the criteria to match traces to a dataset."
        }
      },
      "type": "object"
    },
    "configv1TraceSearchFilter": {
      "properties": {
        "scope_filter": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterScopeFilter"
            }
          ],
          "description": "Scope filter that defines which spans within matching traces contribute to metrics calculation."
        },
        "span": {
          "description": "Specifies the span conditions to match on. All conditions must be true in a\nsingle span for the span to be considered a match. If `span_count` is specified,\nthe number of spans within the trace that match span conditions must be within\n`[min, max]`. You can specify multiple span conditions, and each can be\nsatisfied by any number of spans within the trace.",
          "items": {
            "$ref": "#/$defs/TraceSearchFilterSpanFilter"
          },
          "type": "array"
        },
        "trace": {
          "allOf": [
            {
              "$ref": "#/$defs/TraceSearchFilterTraceFilter"
            }
          ],
          "description": "Trace-level filter criteria (effectively matching the root span)."
        }
      },
      "type": "object"
    }
  }
}