{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://openhydro.org/schemas/v1/test_manifest.schema.json",
  "title": "Benchmark1d2d Test Manifest",
  "description": "Main contract for a benchmark1d2d V&V test case. Declares identity, physics, provenance, inputs, reference solution, simulation setup and scoring tolerances.",
  "type": "object",
  "additionalProperties": false,
  "required": [
    "schema_version",
    "test_id",
    "case_version",
    "status",
    "track",
    "test_class",
    "physics",
    "provenance",
    "inputs",
    "reference",
    "simulation",
    "scoring"
  ],
  "properties": {
    "schema_version": {
      "type": "string",
      "description": "Schema semver this manifest conforms to.",
      "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$"
    },
    "test_id": {
      "type": "string",
      "description": "Unique test identifier. Prefix encodes track and class (A1P, A1F, A2A, A2C = 2D code inter-comparison, A2L, A2F, A12, B).",
      "pattern": "^(A1P|A1F|A1D|A2A|A2C|A2L|A2F|A12|B)-[A-Za-z0-9._-]+$"
    },
    "case_version": {
      "type": "string",
      "description": "Semver of this test case definition.",
      "pattern": "^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?$"
    },
    "status": {
      "type": "string",
      "description": "Lifecycle status. Only frozen cases count toward certification.",
      "enum": [
        "draft",
        "candidate",
        "frozen",
        "deprecated"
      ]
    },
    "track": {
      "type": "string",
      "description": "A = physics verification/validation; B = industry parity.",
      "enum": [
        "A",
        "B"
      ]
    },
    "test_class": {
      "type": "string",
      "description": "Test class constrained by track via if/then rules. 'intercomparison' = no exact or measured truth; scored on objective expected states (conservation, settled levels), with the published package ensemble shown for context only.",
      "enum": [
        "verification_analytic",
        "verification_manufactured",
        "validation_lab",
        "validation_field",
        "validation_coupled",
        "intercomparison",
        "parity",
        "regression",
        "stress"
      ]
    },
    "title": {
      "type": "string",
      "description": "Short human-readable title."
    },
    "description": {
      "type": "string",
      "description": "Longer description of the test case."
    },
    "physics": {
      "$ref": "#/$defs/physics"
    },
    "provenance": {
      "$ref": "#/$defs/provenance"
    },
    "inputs": {
      "type": "array",
      "description": "Input files with integrity hashes.",
      "minItems": 1,
      "items": {
        "$ref": "#/$defs/input_file"
      }
    },
    "reference": {
      "$ref": "#/$defs/reference"
    },
    "simulation": {
      "$ref": "#/$defs/simulation"
    },
    "scoring": {
      "$ref": "#/$defs/scoring"
    },
    "review": {
      "type": "object",
      "description": "Maintainer sign-off required to freeze a case (docs/methodology/promotion.md).",
      "additionalProperties": false,
      "required": [
        "by",
        "date"
      ],
      "properties": {
        "by": {
          "type": "string",
          "minLength": 2
        },
        "date": {
          "type": "string",
          "format": "date"
        },
        "notes": {
          "type": "string"
        }
      }
    }
  },
  "allOf": [
    {
      "if": {
        "properties": {
          "track": {
            "const": "A"
          }
        },
        "required": [
          "track"
        ]
      },
      "then": {
        "properties": {
          "test_class": {
            "enum": [
              "verification_analytic",
              "verification_manufactured",
              "validation_lab",
              "validation_field",
              "validation_coupled",
              "intercomparison"
            ]
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "track": {
            "const": "B"
          }
        },
        "required": [
          "track"
        ]
      },
      "then": {
        "properties": {
          "test_class": {
            "enum": [
              "parity",
              "regression",
              "stress"
            ]
          },
          "reference": {
            "properties": {
              "kind": {
                "const": "pinned_engine"
              }
            },
            "required": [
              "kind"
            ]
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "test_class": {
            "type": "string",
            "pattern": "^verification"
          }
        },
        "required": [
          "test_class"
        ]
      },
      "then": {
        "anyOf": [
          {
            "properties": {
              "simulation": {
                "type": "object",
                "required": [
                  "mesh_refinement"
                ],
                "properties": {
                  "mesh_refinement": {
                    "type": "object",
                    "required": [
                      "levels"
                    ],
                    "properties": {
                      "levels": {
                        "type": "array",
                        "minItems": 3,
                        "items": {
                          "type": "number"
                        }
                      }
                    }
                  }
                }
              },
              "scoring": {
                "type": "object",
                "required": [
                  "convergence"
                ],
                "properties": {
                  "convergence": {
                    "type": "object",
                    "required": [
                      "expected_order",
                      "min_observed_order"
                    ]
                  }
                }
              }
            },
            "required": [
              "simulation",
              "scoring"
            ]
          },
          {
            "properties": {
              "scoring": {
                "type": "object",
                "required": [
                  "convergence"
                ],
                "properties": {
                  "convergence": {
                    "type": "object",
                    "required": [
                      "not_applicable"
                    ],
                    "properties": {
                      "not_applicable": {
                        "type": "string",
                        "minLength": 20
                      }
                    }
                  }
                }
              }
            },
            "required": [
              "scoring"
            ]
          }
        ]
      }
    },
    {
      "if": {
        "properties": {
          "scoring": {
            "type": "object",
            "properties": {
              "pass_rule": {
                "const": "weighted"
              }
            },
            "required": [
              "pass_rule"
            ]
          }
        },
        "required": [
          "scoring"
        ]
      },
      "then": {
        "properties": {
          "scoring": {
            "type": "object",
            "required": [
              "minimum_score"
            ],
            "properties": {
              "minimum_score": {
                "type": "number",
                "minimum": 0,
                "maximum": 1
              }
            }
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "test_class": {
            "const": "intercomparison"
          }
        },
        "required": [
          "test_class"
        ]
      },
      "then": {
        "properties": {
          "reference": {
            "properties": {
              "kind": {
                "const": "intercomparison"
              }
            },
            "required": [
              "kind"
            ]
          }
        }
      }
    },
    {
      "if": {
        "properties": {
          "status": {
            "enum": [
              "candidate",
              "frozen"
            ]
          }
        },
        "required": [
          "status"
        ]
      },
      "then": {
        "properties": {
          "inputs": {
            "items": {
              "not": {
                "required": [
                  "pending"
                ]
              }
            }
          }
        }
      }
    }
  ],
  "$defs": {
    "physics": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "dimensionality",
        "flow_type",
        "governing_equations",
        "phenomena"
      ],
      "properties": {
        "dimensionality": {
          "type": "string",
          "enum": [
            "1D",
            "2D",
            "1D2D"
          ]
        },
        "flow_type": {
          "type": "string",
          "enum": [
            "pressurized",
            "free_surface",
            "mixed"
          ]
        },
        "governing_equations": {
          "type": "array",
          "minItems": 1,
          "items": {
            "type": "string",
            "minLength": 1
          },
          "uniqueItems": true
        },
        "phenomena": {
          "type": "array",
          "minItems": 1,
          "items": {
            "type": "string",
            "minLength": 1
          },
          "uniqueItems": true
        }
      }
    },
    "provenance": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "citations",
        "license"
      ],
      "properties": {
        "citations": {
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/$defs/citation"
          }
        },
        "license": {
          "type": "string",
          "minLength": 1,
          "description": "Must match an entry in DATA_LICENSES.md."
        },
        "source_dataset_doi": {
          "type": "string",
          "description": "Optional DOI of the source dataset."
        },
        "adaptation_notes": {
          "type": "string",
          "description": "Notes on how source data was adapted for this case."
        }
      }
    },
    "citation": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "title"
      ],
      "properties": {
        "title": {
          "type": "string",
          "minLength": 1
        },
        "authors": {
          "type": "array",
          "items": {
            "type": "string"
          }
        },
        "year": {
          "type": "integer"
        },
        "doi": {
          "type": "string",
          "minLength": 1
        },
        "url": {
          "type": "string",
          "format": "uri"
        },
        "isbn": {
          "type": "string",
          "minLength": 1
        },
        "report_number": {
          "type": "string",
          "minLength": 1
        }
      },
      "anyOf": [
        {
          "required": [
            "doi"
          ]
        },
        {
          "required": [
            "url"
          ]
        },
        {
          "required": [
            "isbn"
          ]
        },
        {
          "required": [
            "report_number"
          ]
        }
      ]
    },
    "input_file": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "path",
        "role",
        "format"
      ],
      "properties": {
        "path": {
          "type": "string",
          "minLength": 1,
          "description": "Relative path within the test case folder."
        },
        "role": {
          "type": "string",
          "minLength": 1,
          "description": "Semantic role (e.g. network, terrain, forcing, initial_condition)."
        },
        "format": {
          "type": "string",
          "minLength": 1,
          "description": "File format identifier (e.g. json, inp, geotiff, ugrid)."
        },
        "sha256": {
          "type": "string",
          "pattern": "^[a-fA-F0-9]{64}$",
          "description": "SHA-256 hex digest of the file contents (after extraction from source archive, if any)."
        },
        "crs": {
          "type": "string",
          "description": "Optional CRS (EPSG code or WKT)."
        },
        "source": {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "url"
          ],
          "description": "Where a non-committed input is fetched from. scripts/fetch_inputs.py downloads, checks archive_sha256, extracts 'members' (outer-to-inner archive path chain) and checks sha256.",
          "properties": {
            "url": {
              "type": "string",
              "format": "uri"
            },
            "archive_sha256": {
              "type": "string",
              "pattern": "^[a-fA-F0-9]{64}$"
            },
            "members": {
              "type": "array",
              "minItems": 1,
              "items": {
                "type": "string",
                "minLength": 1
              }
            },
            "doi": {
              "type": "string"
            },
            "md5": {
              "type": "string",
              "pattern": "^[a-fA-F0-9]{32}$",
              "description": "Publisher-supplied MD5 (e.g. figshare computed_md5) when no SHA-256 has been recorded yet."
            }
          }
        },
        "committed": {
          "type": "boolean",
          "default": true,
          "description": "False = file is not in git; it is fetched from 'source' and verified by sha256."
        },
        "pending": {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "reason"
          ],
          "description": "Input not yet obtained. Allowed only while status is draft.",
          "properties": {
            "reason": {
              "type": "string",
              "minLength": 1
            },
            "obtain_from": {
              "type": "string"
            }
          }
        }
      },
      "anyOf": [
        {
          "required": [
            "sha256"
          ]
        },
        {
          "required": [
            "pending"
          ]
        }
      ]
    },
    "reference": {
      "oneOf": [
        {
          "$ref": "#/$defs/reference_analytic"
        },
        {
          "$ref": "#/$defs/reference_measured"
        },
        {
          "$ref": "#/$defs/reference_pinned_engine"
        },
        {
          "$ref": "#/$defs/reference_intercomparison"
        },
        {
          "$ref": "#/$defs/reference_exact_states"
        }
      ]
    },
    "reference_analytic": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "kind",
        "generator"
      ],
      "properties": {
        "kind": {
          "const": "analytic"
        },
        "generator": {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "module",
            "function",
            "parameters"
          ],
          "properties": {
            "module": {
              "type": "string",
              "minLength": 1
            },
            "function": {
              "type": "string",
              "minLength": 1
            },
            "parameters": {
              "type": "object",
              "additionalProperties": true
            }
          }
        }
      }
    },
    "reference_measured": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "kind",
        "data_path",
        "uncertainty"
      ],
      "properties": {
        "kind": {
          "const": "measured"
        },
        "data_path": {
          "type": "string",
          "minLength": 1
        },
        "uncertainty": {
          "$ref": "#/$defs/uncertainty"
        },
        "include_measurement_uncertainty": {
          "type": "boolean",
          "description": "When true, scoring absorbs stated measurement uncertainty."
        },
        "availability": {
          "type": "string",
          "enum": [
            "available",
            "to_digitise",
            "request_from_authors",
            "pending_license"
          ],
          "description": "State of the measured reference data."
        },
        "probe_map": {
          "type": "object",
          "additionalProperties": {
            "type": "string"
          },
          "description": "Optional map from simulation probe id to measured gauge id."
        }
      }
    },
    "reference_pinned_engine": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "kind",
        "engine",
        "version",
        "binary_sha256"
      ],
      "properties": {
        "kind": {
          "const": "pinned_engine"
        },
        "engine": {
          "type": "string",
          "minLength": 1
        },
        "version": {
          "type": "string",
          "minLength": 1
        },
        "binary_sha256": {
          "type": "string",
          "pattern": "^[a-fA-F0-9]{64}$"
        },
        "build": {
          "type": "string",
          "description": "Which build produced the cached reference results, e.g. 'swmm-toolkit 0.17.0 (EPA SWMM 5.2.4 engine)'."
        },
        "results_path": {
          "type": "string",
          "description": "Case-relative path of the reference results Parquet produced by the pinned engine (regenerate with scripts/make_reference.py)."
        }
      }
    },
    "uncertainty": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "type"
      ],
      "properties": {
        "type": {
          "type": "string",
          "enum": [
            "absolute",
            "relative",
            "combined",
            "per_variable"
          ]
        },
        "value": {
          "type": "number"
        },
        "units": {
          "type": "string"
        },
        "variables": {
          "type": "object",
          "additionalProperties": {
            "type": "object",
            "additionalProperties": false,
            "properties": {
              "absolute": {
                "type": "number"
              },
              "relative": {
                "type": "number"
              },
              "units": {
                "type": "string"
              }
            }
          }
        },
        "notes": {
          "type": "string"
        }
      }
    },
    "simulation": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "t_end",
        "output_interval",
        "required_outputs"
      ],
      "properties": {
        "t_end": {
          "type": "number",
          "exclusiveMinimum": 0,
          "description": "Simulation end time (seconds)."
        },
        "output_interval": {
          "type": "number",
          "exclusiveMinimum": 0,
          "description": "Output sampling interval (seconds)."
        },
        "required_outputs": {
          "type": "array",
          "minItems": 1,
          "uniqueItems": true,
          "items": {
            "type": "string",
            "enum": [
              "t",
              "x",
              "y",
              "h",
              "u",
              "v",
              "p",
              "Q",
              "c",
              "z",
              "V"
            ]
          }
        },
        "probes": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/probe"
          }
        },
        "mesh_refinement": {
          "$ref": "#/$defs/mesh_refinement"
        },
        "solver_freedoms": {
          "type": "object",
          "description": "Optional solver parameters the adapter may expose.",
          "additionalProperties": true
        },
        "steady": {
          "type": "boolean",
          "description": "The reference is a steady state; t_end only bounds a time-marching solver."
        },
        "epoch": {
          "type": "string",
          "format": "date-time",
          "description": "Calendar time of t = 0, for a test run on real dates (field cases); results' t counts seconds from it."
        },
        "events": {
          "type": "array",
          "description": "Separate runs on real dates (field cases). Each is run on its own from start to end; t continues from the epoch, so the runs' results concatenate.",
          "items": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "id",
              "start",
              "end"
            ],
            "properties": {
              "id": {
                "type": "string",
                "minLength": 1
              },
              "start": {
                "type": "string",
                "format": "date-time",
                "description": "Start of the run, including the warm-up."
              },
              "score_from": {
                "type": "string",
                "format": "date-time",
                "description": "Start of the scored window (after the warm-up)."
              },
              "end": {
                "type": "string",
                "format": "date-time"
              }
            }
          }
        }
      }
    },
    "probe": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "id"
      ],
      "properties": {
        "id": {
          "type": "string",
          "minLength": 1
        },
        "x": {
          "type": "number"
        },
        "y": {
          "type": "number"
        },
        "z": {
          "type": "number"
        },
        "variables": {
          "type": "array",
          "items": {
            "type": "string",
            "enum": [
              "h",
              "u",
              "v",
              "p",
              "Q",
              "c"
            ]
          }
        },
        "element": {
          "type": "string",
          "minLength": 1,
          "description": "A network node or link name: the probe is matched by element_id rather than position."
        }
      },
      "anyOf": [
        {
          "required": [
            "x"
          ]
        },
        {
          "required": [
            "element"
          ]
        }
      ]
    },
    "mesh_refinement": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "levels"
      ],
      "properties": {
        "levels": {
          "type": "array",
          "minItems": 1,
          "items": {
            "type": "number",
            "exclusiveMinimum": 0
          },
          "description": "Characteristic mesh spacings (coarse → fine)."
        },
        "fixed_courant": {
          "type": "number",
          "exclusiveMinimum": 0,
          "description": "Courant number held fixed across refinement levels."
        }
      }
    },
    "scoring": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "criteria",
        "pass_rule"
      ],
      "properties": {
        "criteria": {
          "type": "array",
          "minItems": 1,
          "items": {
            "$ref": "#/$defs/criterion"
          }
        },
        "convergence": {
          "$ref": "#/$defs/convergence"
        },
        "pass_rule": {
          "type": "string",
          "enum": [
            "all_gating",
            "any_gating",
            "weighted"
          ]
        },
        "minimum_score": {
          "type": "number",
          "minimum": 0,
          "maximum": 1,
          "description": "Required when pass_rule is weighted."
        }
      }
    },
    "criterion": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "id",
        "metric",
        "variable",
        "threshold",
        "gating",
        "rationale"
      ],
      "properties": {
        "id": {
          "type": "string",
          "minLength": 1
        },
        "metric": {
          "type": "string",
          "enum": [
            "L1",
            "L2",
            "Linf",
            "global_mass_error",
            "NSE",
            "KGE",
            "peak_error",
            "arrival_time_error",
            "front_position_error",
            "volume_front_error",
            "CSI",
            "relative_peak",
            "relative_volume",
            "timing_error",
            "continuity_error",
            "expected_state_error",
            "relative_head_loss",
            "storage_balance_error"
          ]
        },
        "variable": {
          "type": "string",
          "minLength": 1
        },
        "where": {
          "type": "string",
          "description": "Optional spatial/temporal mask or probe selector."
        },
        "threshold": {
          "$ref": "#/$defs/threshold"
        },
        "gating": {
          "type": "boolean",
          "description": "If true, this criterion participates in the pass_rule."
        },
        "rationale": {
          "type": "string",
          "minLength": 1,
          "description": "Required justification; appears on the public test page."
        },
        "include_measurement_uncertainty": {
          "type": "boolean"
        },
        "weight": {
          "type": "number",
          "minimum": 0,
          "description": "Optional weight for weighted pass_rule."
        },
        "against": {
          "type": "string",
          "description": "For metric expected_state_error: id of a reference.expected_states entry."
        },
        "aggregate": {
          "type": "string",
          "enum": [
            "worst",
            "median"
          ],
          "description": "Measured cases with many gauge records: judge the worst record (default) or the median one."
        }
      }
    },
    "threshold": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "op",
        "value",
        "units"
      ],
      "properties": {
        "op": {
          "type": "string",
          "enum": [
            "abs<=",
            "<=",
            ">=",
            "=="
          ]
        },
        "value": {
          "type": "number"
        },
        "units": {
          "type": "string",
          "minLength": 1
        }
      }
    },
    "convergence": {
      "type": "object",
      "additionalProperties": false,
      "properties": {
        "norm": {
          "type": "string",
          "enum": [
            "L1",
            "L2",
            "Linf"
          ]
        },
        "variable": {
          "type": "string",
          "minLength": 1
        },
        "expected_order": {
          "type": "number",
          "exclusiveMinimum": 0
        },
        "min_observed_order": {
          "type": "number",
          "exclusiveMinimum": 0
        },
        "not_applicable": {
          "type": "string",
          "minLength": 20,
          "description": "Why observed order of accuracy does not apply to this case (the reference is closed-form and the candidate has no discretization to refine)."
        }
      },
      "oneOf": [
        {
          "required": [
            "norm",
            "variable",
            "expected_order",
            "min_observed_order"
          ]
        },
        {
          "required": [
            "not_applicable"
          ],
          "not": {
            "anyOf": [
              {
                "required": [
                  "norm"
                ]
              },
              {
                "required": [
                  "expected_order"
                ]
              }
            ]
          }
        }
      ]
    },
    "reference_intercomparison": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "kind",
        "expected_states",
        "ensemble"
      ],
      "description": "Code inter-comparison: no exact or measured truth. Gating criteria are objective expected states; the published package ensemble is context, never a pass/fail truth.",
      "properties": {
        "kind": {
          "const": "intercomparison"
        },
        "expected_states": {
          "type": "array",
          "minItems": 1,
          "items": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "id",
              "variable",
              "value",
              "units",
              "derivation"
            ],
            "properties": {
              "id": {
                "type": "string",
                "pattern": "^[a-z0-9_]+$"
              },
              "variable": {
                "type": "string"
              },
              "where": {
                "type": "string"
              },
              "time": {
                "type": "number",
                "description": "Seconds; omit for end of run."
              },
              "value": {
                "type": "number"
              },
              "units": {
                "type": "string"
              },
              "derivation": {
                "type": "string",
                "minLength": 1,
                "description": "How the value follows from the inputs (conservation, hydrostatics, published statement)."
              }
            }
          }
        },
        "ensemble": {
          "type": "object",
          "additionalProperties": false,
          "required": [
            "source",
            "availability"
          ],
          "properties": {
            "source": {
              "type": "string"
            },
            "availability": {
              "type": "string",
              "enum": [
                "available",
                "not_digitised",
                "permission_required"
              ]
            },
            "data_path": {
              "type": "string"
            },
            "notes": {
              "type": "string"
            }
          }
        }
      }
    },
    "reference_exact_states": {
      "type": "object",
      "additionalProperties": false,
      "required": [
        "kind",
        "expected_states"
      ],
      "description": "Exact states that follow from the inputs by conservation or hydrostatics (no closed-form field): settled levels, exchanged and discharged volumes, steady exchange flows. Scored like inter-comparison expected states, but the values are exact.",
      "properties": {
        "kind": {
          "const": "exact_states"
        },
        "expected_states": {
          "type": "array",
          "minItems": 1,
          "items": {
            "type": "object",
            "additionalProperties": false,
            "required": [
              "id",
              "variable",
              "value",
              "units",
              "derivation"
            ],
            "properties": {
              "id": {
                "type": "string",
                "pattern": "^[a-z0-9_]+$"
              },
              "variable": {
                "type": "string"
              },
              "where": {
                "type": "string"
              },
              "time": {
                "type": "number",
                "description": "Seconds; omit for end of run."
              },
              "value": {
                "type": "number"
              },
              "units": {
                "type": "string"
              },
              "derivation": {
                "type": "string",
                "minLength": 1,
                "description": "How the value follows from the inputs (conservation, hydrostatics, published statement)."
              },
              "element": {
                "type": "string",
                "description": "Element id (manhole, account) the state refers to, for network or coupled results."
              }
            }
          }
        }
      }
    }
  }
}