flextool 4.0.0__py3-none-any.whl

flextool/schemas/spinedb_schema.json

@@ -0,0 +1,4636 @@
+{
+  "entity_classes": [
+    [
+      "commodity",
+      [],
+      "Stuff that is being processed",
+      281351265055225,
+      true
+    ],
+    [
+      "connection",
+      [],
+      null,
+      280741963428706,
+      false
+    ],
+    [
+      "constraint",
+      [],
+      null,
+      281107035649330,
+      true
+    ],
+    [
+      "flowGroup",
+      [],
+      null,
+      143488754774337,
+      true
+    ],
+    [
+      "group",
+      [],
+      null,
+      280655732797761,
+      true
+    ],
+    [
+      "model",
+      [],
+      "Settings for a model instance",
+      280378317271475,
+      true
+    ],
+    [
+      "node",
+      [],
+      null,
+      280655732797997,
+      false
+    ],
+    [
+      "profile",
+      [],
+      null,
+      280376907921198,
+      true
+    ],
+    [
+      "reserve",
+      [],
+      "Categories for the reservation of capacity",
+      281473533932379,
+      true
+    ],
+    [
+      "solve",
+      [],
+      null,
+      280378317271532,
+      true
+    ],
+    [
+      "timeline",
+      [],
+      null,
+      280378317271144,
+      true
+    ],
+    [
+      "timeset",
+      [],
+      null,
+      280378317272400,
+      true
+    ],
+    [
+      "unit",
+      [],
+      null,
+      281107035648629,
+      false
+    ],
+    [
+      "upDown",
+      [],
+      null,
+      280378317271864,
+      true
+    ],
+    [
+      "commodity__node",
+      [
+        "commodity",
+        "node"
+      ],
+      "Properties of commodities in particular nodes",
+      281054070108939,
+      true
+    ],
+    [
+      "connection__node",
+      [
+        "connection",
+        "node"
+      ],
+      null,
+      280743406203659,
+      true
+    ],
+    [
+      "connection__profile",
+      [
+        "connection",
+        "profile"
+      ],
+      null,
+      280798025740550,
+      true
+    ],
+    [
+      "group__connection",
+      [
+        "group",
+        "connection"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "group__node",
+      [
+        "group",
+        "node"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "group__unit",
+      [
+        "group",
+        "unit"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "node__profile",
+      [
+        "node",
+        "profile"
+      ],
+      null,
+      280798025740550,
+      true
+    ],
+    [
+      "unit__inputNode",
+      [
+        "unit",
+        "node"
+      ],
+      null,
+      280378317271818,
+      true
+    ],
+    [
+      "unit__outputNode",
+      [
+        "unit",
+        "node"
+      ],
+      null,
+      281473533932299,
+      true
+    ],
+    [
+      "connection__node__node",
+      [
+        "connection",
+        "node",
+        "node"
+      ],
+      null,
+      280743406203746,
+      true
+    ],
+    [
+      "flowGroup__connection__node",
+      [
+        "flowGroup",
+        "connection",
+        "node"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "flowGroup__unit__node",
+      [
+        "flowGroup",
+        "unit",
+        "node"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "reserve__upDown__group",
+      [
+        "reserve",
+        "upDown",
+        "group"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "unit__node__profile",
+      [
+        "unit",
+        "node",
+        "profile"
+      ],
+      null,
+      280798025740550,
+      true
+    ],
+    [
+      "reserve__upDown__connection__node",
+      [
+        "reserve",
+        "upDown",
+        "connection",
+        "node"
+      ],
+      null,
+      null,
+      true
+    ],
+    [
+      "reserve__upDown__unit__node",
+      [
+        "reserve",
+        "upDown",
+        "unit",
+        "node"
+      ],
+      null,
+      null,
+      true
+    ]
+  ],
+  "entities": [
+    [
+      "upDown",
+      "down",
+      "Downward reserve direction"
+    ],
+    [
+      "upDown",
+      "up",
+      "Upward reserve direction"
+    ]
+  ],
+  "parameter_value_lists": [
+    [
+      "capacity_margin_methods",
+      "none"
+    ],
+    [
+      "capacity_margin_methods",
+      "manual"
+    ],
+    [
+      "co2_methods",
+      "none"
+    ],
+    [
+      "co2_methods",
+      "price"
+    ],
+    [
+      "co2_methods",
+      "period"
+    ],
+    [
+      "co2_methods",
+      "total"
+    ],
+    [
+      "co2_methods",
+      "price_period"
+    ],
+    [
+      "co2_methods",
+      "price_total"
+    ],
+    [
+      "co2_methods",
+      "period_total"
+    ],
+    [
+      "co2_methods",
+      "price_period_total"
+    ],
+    [
+      "conversion_methods",
+      "constant_efficiency"
+    ],
+    [
+      "conversion_methods",
+      "min_load_efficiency"
+    ],
+    [
+      "conversion_methods",
+      "none"
+    ],
+    [
+      "decomposition_methods",
+      "none"
+    ],
+    [
+      "decomposition_methods",
+      "benders_regional"
+    ],
+    [
+      "decomposition_schemes",
+      "none"
+    ],
+    [
+      "decomposition_schemes",
+      "benders"
+    ],
+    [
+      "energy_margin_methods",
+      "none"
+    ],
+    [
+      "energy_margin_methods",
+      "inflow_multiplier"
+    ],
+    [
+      "energy_margin_methods",
+      "inflow_adder"
+    ],
+    [
+      "flow_aggregator_methods",
+      "none"
+    ],
+    [
+      "flow_aggregator_methods",
+      "dispatch_plots_only"
+    ],
+    [
+      "flow_aggregator_methods",
+      "standalone_aggregator_only"
+    ],
+    [
+      "flow_aggregator_methods",
+      "both"
+    ],
+    [
+      "has_DC",
+      "yes"
+    ],
+    [
+      "has_invest",
+      "yes"
+    ],
+    [
+      "inflow_methods",
+      "no_inflow"
+    ],
+    [
+      "inflow_methods",
+      "use_original"
+    ],
+    [
+      "inflow_methods",
+      "scale_in_proportion"
+    ],
+    [
+      "inflow_methods",
+      "scale_to_annual_flow"
+    ],
+    [
+      "inflow_methods",
+      "scale_to_annual_and_peak_flow"
+    ],
+    [
+      "invest_methods",
+      "not_allowed"
+    ],
+    [
+      "invest_methods",
+      "invest_no_limit"
+    ],
+    [
+      "invest_methods",
+      "invest_period"
+    ],
+    [
+      "invest_methods",
+      "invest_total"
+    ],
+    [
+      "invest_methods",
+      "invest_period_total"
+    ],
+    [
+      "invest_methods",
+      "retire_no_limit"
+    ],
+    [
+      "invest_methods",
+      "retire_period"
+    ],
+    [
+      "invest_methods",
+      "retire_total"
+    ],
+    [
+      "invest_methods",
+      "retire_period_total"
+    ],
+    [
+      "invest_methods",
+      "invest_retire_no_limit"
+    ],
+    [
+      "invest_methods",
+      "invest_retire_period"
+    ],
+    [
+      "invest_methods",
+      "invest_retire_total"
+    ],
+    [
+      "invest_methods",
+      "invest_retire_period_total"
+    ],
+    [
+      "invest_methods",
+      "cumulative_limits"
+    ],
+    [
+      "lifetime_methods",
+      "reinvest_automatic"
+    ],
+    [
+      "lifetime_methods",
+      "reinvest_choice"
+    ],
+    [
+      "lifetime_methods",
+      "no_investment"
+    ],
+    [
+      "load_share_type",
+      "equal"
+    ],
+    [
+      "load_share_type",
+      "inflow_weighted"
+    ],
+    [
+      "load_share_type",
+      "no"
+    ],
+    [
+      "minimum_time_methods",
+      "min_uptime"
+    ],
+    [
+      "minimum_time_methods",
+      "min_downtime"
+    ],
+    [
+      "minimum_time_methods",
+      "both"
+    ],
+    [
+      "minimum_time_methods",
+      "none"
+    ],
+    [
+      "node_type",
+      "balance_within_period"
+    ],
+    [
+      "node_type",
+      "commodity"
+    ],
+    [
+      "node_type",
+      "balance"
+    ],
+    [
+      "node_type",
+      "storage"
+    ],
+    [
+      "optional_output",
+      "yes"
+    ],
+    [
+      "optional_output",
+      "no"
+    ],
+    [
+      "penalty_methods",
+      "regular"
+    ],
+    [
+      "penalty_methods",
+      "off"
+    ],
+    [
+      "price_method",
+      "price"
+    ],
+    [
+      "price_method",
+      "price_ladder_annual"
+    ],
+    [
+      "price_method",
+      "price_ladder_cumulative"
+    ],
+    [
+      "profile_methods",
+      "upper_limit"
+    ],
+    [
+      "profile_methods",
+      "lower_limit"
+    ],
+    [
+      "profile_methods",
+      "fixed"
+    ],
+    [
+      "profile_methods",
+      "none"
+    ],
+    [
+      "ramp_methods",
+      "ramp_limit"
+    ],
+    [
+      "ramp_methods",
+      "ramp_cost"
+    ],
+    [
+      "ramp_methods",
+      "both"
+    ],
+    [
+      "ramp_methods",
+      "none"
+    ],
+    [
+      "reserve_methods",
+      "no_reserve"
+    ],
+    [
+      "reserve_methods",
+      "timeseries_only"
+    ],
+    [
+      "reserve_methods",
+      "dynamic_only"
+    ],
+    [
+      "reserve_methods",
+      "large_failure_only"
+    ],
+    [
+      "reserve_methods",
+      "timeseries_and_dynamic"
+    ],
+    [
+      "reserve_methods",
+      "timeseries_and_large_failure"
+    ],
+    [
+      "reserve_methods",
+      "dynamic_and_large_failure"
+    ],
+    [
+      "reserve_methods",
+      "all"
+    ],
+    [
+      "results",
+      "summary_only"
+    ],
+    [
+      "results",
+      "limited_period"
+    ],
+    [
+      "results",
+      "limited_period_time"
+    ],
+    [
+      "results",
+      "full_period"
+    ],
+    [
+      "results",
+      "full_period_time"
+    ],
+    [
+      "scaling_modes",
+      "off"
+    ],
+    [
+      "scaling_modes",
+      "solver_only"
+    ],
+    [
+      "scaling_modes",
+      "basic"
+    ],
+    [
+      "scaling_modes",
+      "full"
+    ],
+    [
+      "senses",
+      "greater_than"
+    ],
+    [
+      "senses",
+      "less_than"
+    ],
+    [
+      "senses",
+      "equal"
+    ],
+    [
+      "solve_mode",
+      "single_solve"
+    ],
+    [
+      "solve_mode",
+      "rolling_window"
+    ],
+    [
+      "solver",
+      "glpsol"
+    ],
+    [
+      "solver",
+      "highs"
+    ],
+    [
+      "solver",
+      "cplex"
+    ],
+    [
+      "solvers",
+      "highs"
+    ],
+    [
+      "solvers",
+      "gurobi"
+    ],
+    [
+      "solvers",
+      "cplex"
+    ],
+    [
+      "solvers",
+      "xpress"
+    ],
+    [
+      "solvers",
+      "copt"
+    ],
+    [
+      "startup_methods",
+      "no_startup"
+    ],
+    [
+      "startup_methods",
+      "linear"
+    ],
+    [
+      "startup_methods",
+      "binary"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_within_period"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_within_solve"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_forward_only"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_intraperiod_blocks"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_within_timeblock"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_within_solve_blended_weights"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_within_period_blended_weights"
+    ],
+    [
+      "storage_binding_methods",
+      "bind_forward_only_blended_weights"
+    ],
+    [
+      "storage_nested_fix_method",
+      "fix_nothing"
+    ],
+    [
+      "storage_nested_fix_method",
+      "fix_quantity"
+    ],
+    [
+      "storage_nested_fix_method",
+      "fix_price"
+    ],
+    [
+      "storage_nested_fix_method",
+      "fix_usage"
+    ],
+    [
+      "storage_solve_horizon_methods",
+      "free"
+    ],
+    [
+      "storage_solve_horizon_methods",
+      "use_reference_value"
+    ],
+    [
+      "storage_solve_horizon_methods",
+      "use_reference_price"
+    ],
+    [
+      "storage_start_end_methods",
+      "fix_start"
+    ],
+    [
+      "storage_start_end_methods",
+      "fix_end"
+    ],
+    [
+      "storage_start_end_methods",
+      "fix_start_end"
+    ],
+    [
+      "storage_start_end_methods",
+      "fix_nothing"
+    ],
+    [
+      "transfer_methods",
+      "no_losses_no_variable_cost"
+    ],
+    [
+      "transfer_methods",
+      "regular"
+    ],
+    [
+      "transfer_methods",
+      "exact"
+    ],
+    [
+      "transfer_methods",
+      "variable_cost_only"
+    ],
+    [
+      "transfer_methods",
+      "unidirectional"
+    ],
+    [
+      "transfer_methods_group",
+      "use_connection_transfer_methods"
+    ],
+    [
+      "transfer_methods_group",
+      "no_losses_no_variable_cost"
+    ],
+    [
+      "transfer_methods_group",
+      "regular"
+    ],
+    [
+      "transfer_methods_group",
+      "exact"
+    ],
+    [
+      "transfer_methods_group",
+      "variable_cost_only"
+    ],
+    [
+      "transfer_methods_group",
+      "dc_power_flow_with_angles"
+    ],
+    [
+      "transfer_methods_group",
+      "unidirectional"
+    ],
+    [
+      "yes_no",
+      "yes"
+    ],
+    [
+      "yes_no",
+      "no"
+    ]
+  ],
+  "parameter_groups": [
+    [
+      "basics",
+      "6fa8c7",
+      10
+    ],
+    [
+      "constraint",
+      "a36784",
+      70
+    ],
+    [
+      "emission",
+      "8cbb8a",
+      45
+    ],
+    [
+      "flow_limit",
+      "d9bf96",
+      55
+    ],
+    [
+      "investment",
+      "7fb095",
+      20
+    ],
+    [
+      "model",
+      "a3a3a3",
+      80
+    ],
+    [
+      "network",
+      "d9a8a0",
+      50
+    ],
+    [
+      "output",
+      "9ac2d1",
+      95
+    ],
+    [
+      "reserve",
+      "7aaeb0",
+      40
+    ],
+    [
+      "retirement",
+      "a3b08c",
+      25
+    ],
+    [
+      "solve_advanced",
+      "b56f6f",
+      87
+    ],
+    [
+      "solve_basics",
+      "8c94b0",
+      85
+    ],
+    [
+      "storage",
+      "a598c7",
+      30
+    ],
+    [
+      "tech_advanced",
+      "d9925c",
+      35
+    ],
+    [
+      "timeline",
+      "c2b870",
+      90
+    ]
+  ],
+  "parameter_definitions": [
+    [
+      "commodity",
+      "co2_content",
+      null,
+      null,
+      "[CO2 ton per MWh] Constant.",
+      "emission"
+    ],
+    [
+      "commodity",
+      "price",
+      null,
+      null,
+      "[CUR/MWh or other unit] Price of the commodity. Constant, period or time.",
+      "basics"
+    ],
+    [
+      "commodity",
+      "price_ladder_annual",
+      null,
+      null,
+      "Stepped supply curve for price_method='price_ladder_annual'.  Two forms accepted: 2d map with rows 'tier,price,quantity' applies the same per-year limit every period; 3d map with rows 'period,tier,price,quantity' varies the limit per period.  1-based integer tier.  quantity=inf marks an unbounded tail tier.",
+      "basics"
+    ],
+    [
+      "commodity",
+      "price_ladder_cumulative",
+      null,
+      null,
+      "Stepped supply curve for price_method='price_ladder_cumulative'.  2d map with rows 'tier,price,quantity' — one row per tier, giving the tier's unit price and its cumulative quantity cap.  1-based integer tier index.  quantity=inf marks an unbounded tail tier.  Period-agnostic — the cap is a single total across the full model horizon.",
+      "basics"
+    ],
+    [
+      "commodity",
+      "price_method",
+      "price",
+      "price_method",
+      "How the commodity's price enters the LP.  'price' = scalar or time-series price x flow (current behaviour); 'price_ladder_annual' = stepped supply curve with a per-year quantity cap per tier; 'price_ladder_cumulative' = stepped supply curve with a total-model quantity cap per tier (handoff-carried across rolling solves).",
+      "basics"
+    ],
+    [
+      "commodity",
+      "unitsize",
+      null,
+      null,
+      "Per-commodity scaling coefficient applied to the v_trade tier variable when the commodity uses the price-ladder feature (gated by commodity.price_method = price_ladder_annual or price_ladder_cumulative).  When set, v_trade is expressed in user-MWh divided by this value; pick the unitsize so the largest tier quantity sits at O(10) in the scaled LP.  The coefficient multiplies v_trade in the commodity_ladder_balance LHS, the per-tier cap LHS, and the per-tier objective term.  When absent (the default), the price-ladder consumer substitutes 1.0 internally so v_trade is in user-MWh (identity scaling).  Ignored entirely when commodity.price_method is not a price_ladder_* value.",
+      "basics"
+    ],
+    [
+      "connection",
+      "availability",
+      1.0,
+      null,
+      "[e.g. 0.9 means 90%] Fraction of capacity available for connection flows. Constant, period, time or period+time.",
+      "basics"
+    ],
+    [
+      "connection",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places the cumulative pre-built capacity at period d — data baseline plus every v_invest made in periods strictly BEFORE d, retirements ignored — on the left side of the user-defined constraint. Enables learning-effect and period-over-period growth limits. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "connection",
+      "constraint_invested_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places v_invest[e, d] — new-build capacity decided in the current period — on the left side of the user-defined constraint. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "connection",
+      "cumulative_max_capacity",
+      null,
+      null,
+      "[MW] Maximum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "cumulative_min_capacity",
+      null,
+      null,
+      "[MW] Minimum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "delay",
+      null,
+      null,
+      "[hours] A time delay between the input node and the output node - works only with one-way connections (or units). Either a constant indicating the time difference in hours or a map of time differences (index: time difference in hours, value: weight). Each weight indicates its share of the original flow and the weights should sum to 1. Requires that the time resolutions in the model are always integer multiples of these time differences.",
+      "tech_advanced"
+    ],
+    [
+      "connection",
+      "discount_rate",
+      0.05,
+      null,
+      "[e.g. 0.05 equals 5%] Discount rate for investments (WACC). Reflects the financing cost and risk premium for this technology. When the model inflation_rate > 0, this should be a nominal rate. When inflation_rate = 0, this should be a real rate. Used to annualize investment costs over the lifetime. Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "efficiency",
+      1.0,
+      null,
+      "[factor, typically between 0-1] Efficiency of a connection. Constant or time.",
+      "basics"
+    ],
+    [
+      "connection",
+      "existing",
+      null,
+      null,
+      "[MW] Existing capacity. Constant or period.",
+      "basics"
+    ],
+    [
+      "connection",
+      "fixed_cost",
+      null,
+      null,
+      "[CUR/kW] Annual fixed cost. Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_cost",
+      null,
+      null,
+      "[CUR/kW] Investment cost for new 'virtual' capacity. Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_max_period",
+      null,
+      null,
+      "[MW] Maximum investment. Period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_max_total",
+      null,
+      null,
+      "[MW] Maximum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_method",
+      "not_allowed",
+      "invest_methods",
+      "Choice of investment method: not_allowed, invest and retire indicate availability of investment and retirement. no_limit removes all limits even if there are limiting values set. period uses values set in invest/retire_max/min_period. total uses values set in invest/retire_max/min_total.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_min_period",
+      null,
+      null,
+      "[MW] Minimum investment. Period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "invest_min_total",
+      null,
+      null,
+      "[MW] Minimum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "connection",
+      "is_DC",
+      "no",
+      "yes_no",
+      "A flag whether the connection is DC (the flow will not be counted as synchronous if there is a non_synchronous_limit). Default false.",
+      "network"
+    ],
+    [
+      "connection",
+      "lifetime",
+      null,
+      null,
+      "[years] Used to calculate annuity together with interest rate. Constant or period.",
+      "investment"
+    ],
+    [
+      "connection",
+      "lifetime_method",
+      "reinvest_automatic",
+      "lifetime_methods",
+      "Choice how the investments behave after unit runs out of lifetime. Automatic reinvestment causes the model to keep the capacity until the end of model horizon and applies the annualized investment cost without further model choice. Choice of reinvestment removes the capacity at the end of the lifetime and the model needs to decide how much new capacity is to be built.",
+      "investment"
+    ],
+    [
+      "connection",
+      "other_operational_cost",
+      null,
+      null,
+      "[CUR/MWh] Other operational variable cost for trasferring over the connection. Constant, period, time or period+time.",
+      "basics"
+    ],
+    [
+      "connection",
+      "reactance",
+      null,
+      null,
+      "[p.u.] Per-unit reactance of the transmission line. Used for DC power flow when the connection is within a nodeGroup that has transfer_method set to dc_power_flow_with_angles. The susceptance used in the flow equation is base_MVA / reactance.",
+      "network"
+    ],
+    [
+      "connection",
+      "retire_max_period",
+      null,
+      null,
+      "[MW] Maximum retired capacity. Period.",
+      "retirement"
+    ],
+    [
+      "connection",
+      "retire_max_total",
+      null,
+      null,
+      "[MW] Maximum retired capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "connection",
+      "retire_min_period",
+      null,
+      null,
+      "[MW] Maximum retired capacity. Period.",
+      "retirement"
+    ],
+    [
+      "connection",
+      "retire_min_total",
+      null,
+      null,
+      "[MW] Minimum retired capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "connection",
+      "salvage_value",
+      null,
+      null,
+      "[CUR/kW] Salvage value for retiring capacity. Constant or period.",
+      "retirement"
+    ],
+    [
+      "connection",
+      "startup_cost",
+      null,
+      null,
+      "[CUR/MW] Cost of starting up one MW of 'virtual' capacity. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "connection",
+      "startup_method",
+      "no_startup",
+      "startup_methods",
+      "Choice of startup method",
+      "tech_advanced"
+    ],
+    [
+      "connection",
+      "transfer_method",
+      "regular",
+      "transfer_methods",
+      "Choice of transfer method. Options: regular (default), no_losses_no_variable_cost, variable_cost_only, exact, unidirectional. 'unidirectional' restricts flow to source → sink only (single non-negative variable); 'regular'/'exact'/'variable_cost_only' are bidirectional two-variable variants; 'no_losses_no_variable_cost' is a single signed variable with no losses and no VOM.",
+      "basics"
+    ],
+    [
+      "connection",
+      "virtual_unitsize",
+      null,
+      null,
+      "[MW] Size of single connection - used for integer (lumped) investments.",
+      "basics"
+    ],
+    [
+      "connection__node",
+      "constraint_flow_coeff",
+      null,
+      null,
+      "A map of coefficients (Index: constraint name, value: coefficient) to represent the participation of the flow from the connection to a node in user-defined constraints. [flow x coefficient] will be on the left side of the equation.",
+      "constraint"
+    ],
+    [
+      "connection__profile",
+      "profile_method",
+      "none",
+      "profile_methods",
+      "Choice of profile method (upper_limit, lower_limit, fixed). Negative values also possible.\n",
+      "basics"
+    ],
+    [
+      "constraint",
+      "constant",
+      0.0,
+      null,
+      "A constant offset for a user constraint (typically zero). The constant will be on the right side of the equation.",
+      "constraint"
+    ],
+    [
+      "constraint",
+      "is_enabled",
+      "yes",
+      "yes_no",
+      "Whether the entity is enabled. Set to 'no' to disable without deleting the entity. Constant.",
+      "constraint"
+    ],
+    [
+      "constraint",
+      "sense",
+      "equal",
+      "senses",
+      "The sense of the constraint ('greater_than', 'less_than' or 'equal').",
+      "constraint"
+    ],
+    [
+      "flowGroup",
+      "flow_aggregator",
+      "none",
+      "flow_aggregator_methods",
+      "Choice of flow-aggregation method for this flowGroup: 'none' (used for flow limits only, no aggregated output), 'dispatch_plots_only' (used as an aggregated flowGroup within 'print_dispatch' group of nodes - do not include one flow in multiple flow aggregators to avoid double counting), 'standalone_aggregator_only' (just make time series available for manual output processing / simple plots), 'both'.",
+      "output"
+    ],
+    [
+      "flowGroup",
+      "max_cumulative_flow",
+      null,
+      null,
+      "[MW] Maximum average flow, which limits the cumulative flow for a group of connection_nodes and/or unit_nodes. The average value is multiplied by the model duration to get the cumulative limit (e.g. by 8760 if a single year is modelled). Applied for each solve. Constant or period.",
+      "flow_limit"
+    ],
+    [
+      "flowGroup",
+      "max_instant_flow",
+      null,
+      null,
+      "[MW] Maximum instantenous flow for the aggregated flow of all group members. Constant, period, time or period+time.",
+      "flow_limit"
+    ],
+    [
+      "flowGroup",
+      "min_cumulative_flow",
+      null,
+      null,
+      "[MW] Minimum average flow, which limits the cumulative flow for a group of connection_nodes and/or unit_nodes. The average value is multiplied by the model duration to get the cumulative limit (e.g. by 8760 if a single year is modelled). Applied for each solve. Constant or period.",
+      "flow_limit"
+    ],
+    [
+      "flowGroup",
+      "min_instant_flow",
+      null,
+      null,
+      "[MW] Minimum instantenous flow for the aggregated flow of all group members. Constant, period, time or period+time.",
+      "flow_limit"
+    ],
+    [
+      "group",
+      "base_MVA",
+      null,
+      null,
+      "[MVA] Base power for the per-unit system used in DC power flow. Default 100. susceptance = base_MVA / reactance_pu.",
+      "network"
+    ],
+    [
+      "group",
+      "candidate_precapacity_to_avoid_big_m",
+      null,
+      null,
+      "[MW] Small pre-existing capacity assigned to investment candidate connections in DC power flow groups that have zero existing capacity. This avoids the need for big-M / MIP constraints by ensuring the angle constraint is always active. Default 0.1 MW. The value should be small enough to not affect results but large enough for numerical stability.",
+      "network"
+    ],
+    [
+      "group",
+      "capacity_margin",
+      null,
+      null,
+      "[MW] How much capacity a node group is required to have in addition to the peak net load in the investment time series. Used only by the investment mode. Constant or period.",
+      "investment"
+    ],
+    [
+      "group",
+      "capacity_margin_method",
+      "none",
+      "capacity_margin_methods",
+      "Whether the node group enforces a capacity margin in the investment mode. 'none' (default) = no constraint. 'manual' requires the group to have 'capacity_margin' MW of capacity above the peak net load. Replaces the former has_capacity_margin yes/no flag; reserved for a future 'automatic' mode.",
+      "investment"
+    ],
+    [
+      "group",
+      "co2_max_period",
+      null,
+      null,
+      "[tCO2] Annualized maximum limit for emitted CO2 in each period.",
+      "emission"
+    ],
+    [
+      "group",
+      "co2_max_total",
+      null,
+      null,
+      "[tCO2] Maximum limit for emitted CO2 in the whole solve.",
+      "emission"
+    ],
+    [
+      "group",
+      "co2_method",
+      "none",
+      "co2_methods",
+      "Choice of the CO2 method: none, price, period, total, price_period, price_total, period_total, price_period_total",
+      "emission"
+    ],
+    [
+      "group",
+      "co2_price",
+      null,
+      null,
+      "[CUR/ton] CO2 price for a group of nodes. Constant, period, time or period+time.",
+      "emission"
+    ],
+    [
+      "group",
+      "cumulative_max_capacity",
+      null,
+      null,
+      "[MW or MWh] Maximum cumulative capacity for a group of entities (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "group",
+      "cumulative_min_capacity",
+      null,
+      null,
+      "[MW or MWh] Minimum cumulative capacity for a group of entities (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "group",
+      "decomposition_method",
+      "none",
+      "decomposition_methods",
+      "Decomposition strategy to apply to this group. Currently supported: 'none' (no decomposition — default), 'benders_regional' (group is solved as an independent region in the Benders master/subproblem decomposition, with shared-commodity trade coupling handled by the master).",
+      "solve_advanced"
+    ],
+    [
+      "group",
+      "has_inertia",
+      "no",
+      "yes_no",
+      "A flag whether the group of nodes has an inertia constraint active.\n",
+      "network"
+    ],
+    [
+      "group",
+      "has_non_synchronous",
+      "no",
+      "yes_no",
+      "A flag whether the group of nodes has the non-synchronous share constraint active.",
+      "network"
+    ],
+    [
+      "group",
+      "include_stochastics",
+      "no",
+      "yes_no",
+      "Includes the stochastic branches to be used for the nodes/units/connections in this group",
+      "model"
+    ],
+    [
+      "group",
+      "inertia_limit",
+      null,
+      null,
+      "[MWs] Minimum for synchronous inertia in the group of nodes. Constant or period.",
+      "network"
+    ],
+    [
+      "group",
+      "invest_max_period",
+      null,
+      null,
+      "[MW or MWh] Maximum investment per period to the virtual capacity of a group of units or to the storage capacity of a group of nodes. Period.",
+      "investment"
+    ],
+    [
+      "group",
+      "invest_max_total",
+      null,
+      null,
+      "[MW or MWh] Maximum investment to the virtual capacity of a group of units or to the storage capacity of a group of nodes. Total over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "group",
+      "invest_method",
+      "not_allowed",
+      "invest_methods",
+      "Choice of investment method: not_allowed, invest and retire indicate availability of investment and retirement. no_limit removes all limits even if there are limiting values set. period uses values set in invest/retire_max/min_period. total uses values set in invest/retire_max/min_total.\r\n",
+      "investment"
+    ],
+    [
+      "group",
+      "invest_min_period",
+      null,
+      null,
+      "[MW or MWh] Minimum investment per period to the virtual capacity of a group of units or to the storage capacity of a group of nodes. Period.",
+      "investment"
+    ],
+    [
+      "group",
+      "invest_min_total",
+      null,
+      null,
+      "[MW or MWh] Minimum investment to the virtual capacity of a group of units or to the storage capacity of a group of nodes. Total over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "group",
+      "new_stepduration",
+      null,
+      null,
+      "Hours. Members of this group operate at this step duration. Overrides the solve-level new_stepduration for these entities. Used for multi-resolution models where some nodes (e.g. fuel markets) need coarser dispatch resolution than others (e.g. power systems).",
+      "timeline"
+    ],
+    [
+      "group",
+      "non_synchronous_limit",
+      null,
+      null,
+      "[share, e.g. 0.8 means 80%] The maximum share of non-synchronous generation in the node group. Constant or period.",
+      "network"
+    ],
+    [
+      "group",
+      "penalty_capacity_margin",
+      5000.0,
+      null,
+      "[CUR/kW] Penalty for violating the capacity margin constraint. Uses operational discounting (not annualized over lifetime like investment costs), so the value is not directly comparable to annualized investment costs. Constant or period.",
+      "investment"
+    ],
+    [
+      "group",
+      "penalty_inertia",
+      5000.0,
+      null,
+      "[CUR/MWs] Penalty for violating the inertia constraint. Cost scales with the duration of the violation. Constant or period.",
+      "network"
+    ],
+    [
+      "group",
+      "penalty_non_synchronous",
+      5000.0,
+      null,
+      "[CUR/MWh] Penalty for violating the non synchronous constraint. Constant or period.",
+      "network"
+    ],
+    [
+      "group",
+      "print_dispatch",
+      null,
+      "yes_no",
+      "Combines unit/connection flows, flowGroup aggregated flows, and other balance elements (slack, demand, internal_losses, etc.) into a set of timeseries and a preconfigured plot per group.",
+      "output"
+    ],
+    [
+      "group",
+      "print_indicators",
+      null,
+      "yes_no",
+      "Output indicators for the set of nodes in the group (Loss of Load, VRE generation, etc.).",
+      "output"
+    ],
+    [
+      "group",
+      "reference_node",
+      null,
+      null,
+      "Name of the reference bus node (angle fixed to zero) for DC power flow. Optional — if not specified, automatically selected as the node with the largest existing capacity in each connected component of the DC power flow network.",
+      "network"
+    ],
+    [
+      "group",
+      "share_loss_of_load",
+      "no",
+      "load_share_type",
+      "Force the upward slack of the nodes in this group to be equal or inflow (demand) weighted",
+      "flow_limit"
+    ],
+    [
+      "group",
+      "transfer_method",
+      "use_connection_transfer_methods",
+      "transfer_methods_group",
+      "Override transfer_method for all connections within this nodeGroup. Options: use_connection_transfer_methods (default, no override), no_losses_no_variable_cost, regular, exact, variable_cost_only, unidirectional, dc_power_flow_with_angles. Setting 'unidirectional' gates every member connection to one-way flow (source → sink only). Setting 'dc_power_flow_with_angles' uses B-theta DC power flow (requires reactance on connections).",
+      "network"
+    ],
+    [
+      "group",
+      "use_for_representative_periods",
+      "no",
+      "yes_no",
+      "A flag whether this group of nodes is an aggregation unit for net-load representative-period selection. When 'yes', the representative-periods preprocessor aggregates the member nodes' net load (demand minus available VRE) into a single regional signal used for clustering; when 'no' (default) the group is ignored by that selection. If no group carries the flag, the selection falls back to per-node net-load signals.",
+      "solve_advanced"
+    ],
+    [
+      "model",
+      "inflation_offset_investment",
+      0.0,
+      null,
+      "[years] Offset for when investment costs occur within a year. Default 0 (beginning of year).",
+      "model"
+    ],
+    [
+      "model",
+      "inflation_offset_operations",
+      0.5,
+      null,
+      "[years] Offset for when operational costs occur within a year. Default 0.5 (middle of year).",
+      "model"
+    ],
+    [
+      "model",
+      "inflation_rate",
+      null,
+      null,
+      "[e.g. 0.02 for 2%] Model-wide inflation rate applied to all future costs. When inputs are in real (constant-price) terms, set to 0. When inputs are in nominal terms, set to expected inflation. Default: 0 (real inputs).",
+      "model"
+    ],
+    [
+      "model",
+      "max_flow_for_unconstrained_variables",
+      1000000.0,
+      null,
+      "[MW] Upper bound assigned to LP variables that have no other cap (invest_no_limit capacity; flows through edges whose capacity_max_coeff is zero; infinite-capacity commodity tiers).  Keep large enough not to constrain the physical solution but small enough to avoid numerical issues (default 1,000,000).",
+      "model"
+    ],
+    [
+      "model",
+      "output_horizon",
+      "no",
+      "yes_no",
+      "Outputs the flows in the horizons. Used for testing the model.",
+      "output"
+    ],
+    [
+      "model",
+      "periods_available",
+      null,
+      null,
+      "(Optional) Array of periods available for the model. Periods that are in the data, but are not in period_timeset.",
+      "model"
+    ],
+    [
+      "model",
+      "small_number_threshold",
+      0.0001,
+      null,
+      "Coefficients and right-hand-side terms whose absolute value is below this are treated as 0 when building the optimisation problem. Reduces the numerical range (conditioning) of the LP. Default 0.0001.",
+      "model"
+    ],
+    [
+      "model",
+      "solves",
+      null,
+      null,
+      "Sequence of solves in the model. Array.",
+      "model"
+    ],
+    [
+      "model",
+      "version",
+      69.0,
+      null,
+      "Contains database version information.",
+      "model"
+    ],
+    [
+      "node",
+      "annual_flow",
+      null,
+      null,
+      "[MWh] Annual flow in energy units (always positive, the sign of inflow defines in/out). Inflow time series can be scaled to match annual flow. By default, there is no scaling of inflow. Constant or period.",
+      "basics"
+    ],
+    [
+      "node",
+      "availability",
+      1.0,
+      null,
+      "[e.g. 0.9 means 90%] Fraction of capacity available for storage. Constant, period, time, period+time or stochastic time.",
+      "basics"
+    ],
+    [
+      "node",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places the cumulative pre-built capacity at period d — data baseline plus every v_invest made in periods strictly BEFORE d, retirements ignored — on the left side of the user-defined constraint. Enables learning-effect and period-over-period growth limits. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "node",
+      "constraint_invested_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places v_invest[e, d] — new-build capacity decided in the current period — on the left side of the user-defined constraint. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "node",
+      "constraint_state_coeff",
+      null,
+      null,
+      "A map of coefficients (Index: constraint name, value: coefficient) to represent the participation of the storage state in user-defined constraints. [state x coefficient] will be on the left side of the equation.",
+      "constraint"
+    ],
+    [
+      "node",
+      "cumulative_max_capacity",
+      null,
+      null,
+      "[MWh] Maximum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "cumulative_min_capacity",
+      null,
+      null,
+      "[MWh] Minimum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "discount_rate",
+      0.05,
+      null,
+      "[e.g. 0.05 equals 5%] Discount rate for investments (WACC). Reflects the financing cost and risk premium for this technology. When the model inflation_rate > 0, this should be a nominal rate. When inflation_rate = 0, this should be a real rate. Used to annualize investment costs over the lifetime. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "energy_margin_adder",
+      0.0,
+      null,
+      "[MWh] Extra demand (negative inflow) added to this node in the investment solve only, when energy_margin_method = 'inflow_adder'. Raises adequacy headroom without changing dispatch demand. 0 = off. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "energy_margin_method",
+      "none",
+      "energy_margin_methods",
+      "How the node's investment-stage energy margin is applied. 'none' (default) = off, no scaling. 'inflow_multiplier' multiplies this node's inflow by 'energy_margin_multiplier' in the solve that carries investment periods only (dispatch solves are unaffected). 'inflow_adder' instead adds 'energy_margin_adder' MWh of extra demand (negative inflow) in that same investment solve. Both offset representative-period VRE optimism that would otherwise cause underinvestment.",
+      "investment"
+    ],
+    [
+      "node",
+      "energy_margin_multiplier",
+      1.0,
+      null,
+      "[factor] Multiplier applied to this node's inflow in the investment solve only, when energy_margin_method = 'inflow_multiplier'. Offsets representative-period VRE optimism (rep-period average VRE availability exceeds the annual average). 1 = off. e.g. 1.1 builds ~10% more capacity to serve the true annual demand under the true (lower) annual VRE. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "existing",
+      null,
+      null,
+      "[MWh] Existing storage capacity. Constant or period.",
+      "basics"
+    ],
+    [
+      "node",
+      "fixed_cost",
+      null,
+      null,
+      "[CUR/kWh] Annual fixed cost for storage. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "inflow",
+      null,
+      null,
+      "[MWh] Inflow into the node (negative is outflow). Constant, time or stochastic time.",
+      "basics"
+    ],
+    [
+      "node",
+      "inflow_method",
+      "use_original",
+      "inflow_methods",
+      "Choice how to treat inflow time series. Empty defaults to 'use_original', which does not scale the time series. 'no_inflow' ignores the inflow time series. 'scale_to_annual_flow' scales the inflow time series by a single factor (shape preserved) so its annual energy equals 'annual_flow'. The annualisation uses each timestep's share of the year: for a full or evenly sampled timeline this is 8760/'hours_in_solve' (every step weighted equally); for a representative timeset with 'timeset_weights', each timestep is weighted by its declared share of the year, so a biased sample of timesteps still annualises correctly. The same weighting is used for energy reporting and operating-cost accounting, so the energy the model is scaled to serve, reports, and costs all coincide. If 'timeset_weights' do not reflect the true representativeness of your selected timesteps, the scaling factor - and therefore the absolute demand level - shifts accordingly; see the per-node 'f' diagnostic (inflow_scaling_diagnostics.csv). 'scale_in_proprotion' calculates a scaling factor by dividing 'annual_flow' with the sum of time series inflow (after it has been annualized using 'timeline_duration_in_years'). (With a representative timeset, the annual-energy match uses 'timeset_weights' as above.) 'scale_to_annual_and_peak_flow' scales the time series to match the 'annual_flow' target while transforming the time series to match the highest load with the 'peak_inflow'. (With a representative timeset, the annual-energy match uses 'timeset_weights' as above; the peak match stays unweighted.)",
+      "basics"
+    ],
+    [
+      "node",
+      "invest_cost",
+      null,
+      null,
+      "[CUR/kWh] Investment cost for new storage capacity. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_forced",
+      null,
+      null,
+      "[MWh] Forces the model to invest exactly this amount of new storage capacity, overriding the investment optimisation (equivalent to setting invest_min and invest_max equal). Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_max_period",
+      null,
+      null,
+      "[MWh] Maximum storage investment. Period.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_max_total",
+      null,
+      null,
+      "[MWh] Maximum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_method",
+      "not_allowed",
+      "invest_methods",
+      "Choice of investment method: either not_allowed or then a combination of 1) investment or retirement and 2) investment limits per period, all periods (total) or no_limits.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_min_period",
+      null,
+      null,
+      "[MWh] Minimum storage investment. Period.",
+      "investment"
+    ],
+    [
+      "node",
+      "invest_min_total",
+      null,
+      null,
+      "[MWh] Minimum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "node",
+      "lifetime",
+      null,
+      null,
+      "[years] Used to calculate annuity together with interest rate. Constant or period.",
+      "investment"
+    ],
+    [
+      "node",
+      "lifetime_method",
+      "reinvest_automatic",
+      "lifetime_methods",
+      "Choice how the investments behave after unit runs out of lifetime. Automatic reinvestment causes the model to keep the capacity until the end of model horizon and applies the annualized investment cost without further model choice. Choice of reinvestment removes the capacity at the end of the lifetime and the model needs to decide how much new capacity is to be built.",
+      "investment"
+    ],
+    [
+      "node",
+      "node_type",
+      "balance",
+      "node_type",
+      "Role of this node in the LP.  'commodity' = price-exposed source/sink with no balance constraint (e.g. fuel imports, no storage); 'balance' = energy balance maintained every timestep (default); 'storage' = balance plus a state variable (battery, reservoir); 'balance_within_period' = balance aggregated over the whole period (e.g. an annual gas budget).",
+      "basics"
+    ],
+    [
+      "node",
+      "peak_inflow",
+      null,
+      null,
+      "[MWh] Highest flow for scaling the inflow. Used only with inflow_method scale_to_annual_and_peak_flow. Constant or period.",
+      "basics"
+    ],
+    [
+      "node",
+      "penalty_down",
+      10000.0,
+      null,
+      "[CUR/MWh] Penalty cost for increasing consumption in the node (excess energy). Constant, period, time, period+time, or stochastic time.",
+      "basics"
+    ],
+    [
+      "node",
+      "penalty_method",
+      "regular",
+      "penalty_methods",
+      "Whether this node has balance penalty (unserved-energy / over-supply slack) variables. 'regular' (default) keeps the penalty_up / penalty_down slack variables that let the node balance be violated at a cost. 'off' removes those slack variables entirely, making the node balance a hard equality (the solve becomes infeasible if the node cannot balance). Use 'off' only if certain that it will not make the model infeasible (a real solution exists) - infeasible models can be very difficult to debug. At the same time, 'off' will reduce variables and can direct infeasibilities to other, more desirable, nodes.",
+      "basics"
+    ],
+    [
+      "node",
+      "penalty_up",
+      10000.0,
+      null,
+      "[CUR/MWh] Penalty cost for decreasing consumption in the node (energy not served). Constant, period, time, period+time, or stochastic time.",
+      "basics"
+    ],
+    [
+      "node",
+      "retire_max_period",
+      null,
+      null,
+      "[MWh] Maximum retired storage capacity. Period.",
+      "retirement"
+    ],
+    [
+      "node",
+      "retire_max_total",
+      null,
+      null,
+      "[MWh] Maximum retired storage capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "node",
+      "retire_min_period",
+      null,
+      null,
+      "[MWh] Minimum retired storage capacity. Period.",
+      "retirement"
+    ],
+    [
+      "node",
+      "retire_min_total",
+      null,
+      null,
+      "[MWh] Minimum retired storage capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "node",
+      "salvage_value",
+      null,
+      null,
+      "[CUR/kWh] Salvage value of the storage. Constant or period.",
+      "retirement"
+    ],
+    [
+      "node",
+      "self_discharge_loss",
+      null,
+      null,
+      "[e.g. 0.01 means 1% every hour] Loss of stored energy over time. Constant or time.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_binding_method",
+      "bind_forward_only",
+      "storage_binding_methods",
+      "Choice how the storage state will be maintained over discontinuous timelines. Seven cycle-scope methods (the state-continuity family): 'bind_within_timeblock' cycles state within each timeblock (cycle closes at block boundaries); 'bind_within_period' cycles within each FlexTool period and chains blocks inside the period; 'bind_within_solve' cycles across the whole solve horizon; 'bind_forward_only' (default) chains state forward across the solve with no end-to-start closure; 'bind_within_solve_blended_weights' is the representative-period variant of bind_within_solve (RP weighting + solve-level cycle closure); 'bind_within_period_blended_weights' is the RP variant of bind_within_period (per-period RP weighting, each period closes independently); 'bind_forward_only_blended_weights' is the RP variant of bind_forward_only (RP weighting, no cycle closure). One additional value, 'bind_intraperiod_blocks', is structurally an aggregation method rather than a cycle-scope method: state is held constant within each block and the block-total flow is balanced at the boundary. Silent-degrade behaviour: any '*_blended_weights' method on a node in a solve whose active timeset has no representative_period_weights is automatically downgraded to the corresponding non-RP variant for that solve, so the same storage entity can drive an RP investment solve and a chronological dispatch solve back-to-back. Separate parameters (e.g. 'storage_state_start') can force additional bindings. By default, storage start state is bound to 0.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_nested_fix_method",
+      "fix_nothing",
+      "storage_nested_fix_method",
+      "Used in nested solve sequences. Set this storage as a long term storage, which end state is passed to the lower level solves as a target. *Fix_price* requires `storage_state_reference_price`",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_solve_horizon_method",
+      "free",
+      "storage_solve_horizon_methods",
+      "Choice how to treat storage state at the end of time horizon of each solve. 'free' lets the model choose the end state. 'use_reference_value' forces the end state to the specific value set in 'storage_state_reference_value'. 'use_reference_price' gives the storage state a price in the objective function based on the 'storage_state_reference_price'. ",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_start_end_method",
+      "fix_start",
+      "storage_start_end_methods",
+      "Choice whether the start and end states of storage are fixed in the beginning and end of the whole model timeline (not between solves). Uses 'storage_state_start' and 'storage_state_end'. Options: 'fix_nothing', 'fix_start', 'fix_end', 'fix_start_end'. By default, storage start state is bound to 0 to avoid creation of free energy.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_state_end",
+      null,
+      null,
+      "[0-1] Relative state of storage at the end of the last model solve (overrides 'storage_state_end_reference'). Constant.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_state_reference_price",
+      null,
+      null,
+      "[CUR/MWh] Price for the stored energy at the end of the solve horizon. Requires 'use_reference_price' in 'storage_solve_horizon_method'. Constant or period.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_state_reference_value",
+      null,
+      null,
+      "[0-1] Relative state of storage at then end of each solve (can be overwritten in the next solve).  Requires 'use_reference_value' in 'storage_solve_horizon_method'. Constant, period, time or period+time.",
+      "storage"
+    ],
+    [
+      "node",
+      "storage_state_start",
+      null,
+      null,
+      "[0-1] Relative state of storage at the beginning of the first model solve (irrespective of when the model starts). Constant.",
+      "storage"
+    ],
+    [
+      "node",
+      "virtual_unitsize",
+      null,
+      null,
+      "[MWh] Size of a single storage unit - used for integer investments (lumped investments). If not given, assumed from the existing storage capacity.",
+      "basics"
+    ],
+    [
+      "node__profile",
+      "profile_method",
+      "none",
+      "profile_methods",
+      "Choice of profile method (upper_limit, lower_limit, fixed). Negative values also possible.\n",
+      "basics"
+    ],
+    [
+      "profile",
+      "profile",
+      null,
+      null,
+      "[factor, typically between 0-1]. Availability time series for a fluctuating resource like wind power. Time or stochastic time.",
+      "basics"
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "increase_reserve_ratio",
+      null,
+      null,
+      "[factor] The reserve requirement is increased by the flow from the connection to the node multiplied by this ratio. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "is_enabled",
+      "yes",
+      "yes_no",
+      "Whether the entity is enabled. Set to 'no' to disable without deleting the entity. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "large_failure_ratio",
+      null,
+      null,
+      "[factor] Each connection using the N-1 failure method will have a separate constraint to require sufficient reserve to cover a failure of the unit generation (multiplied by this ratio). Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "max_share",
+      null,
+      null,
+      "[factor] Maximum ratio for the transfer of reserve to this node. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "reliability",
+      1.0,
+      null,
+      "[factor] The share of the reservation that is counted to reserves (sometimes reserve sources are not fully trusted). Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__group",
+      "increase_reserve_ratio",
+      null,
+      null,
+      "[factor] The reserve is increased by the sum of demands from the group members multiplied by this ratio. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__group",
+      "penalty_reserve",
+      null,
+      null,
+      "[CUR/MW] Penalty for violating a reserve constraint. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__group",
+      "reservation",
+      null,
+      null,
+      "[MW] Amount of reserve to be reserved. Constant, period, time, period+time or stochastic time.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__group",
+      "reserve_method",
+      "no_reserve",
+      "reserve_methods",
+      "Choice of reserve method: no_reserve, timeseries_only, dynamic_only, large_failure_only, timeseries_and_dynamic, timeseries_and_large_failure, dynamic_and_large_failure, all",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "increase_reserve_ratio",
+      null,
+      null,
+      "[factor] The reserve requirement is increased by generation from the unit to the node multiplied by this ratio. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "is_enabled",
+      "yes",
+      "yes_no",
+      "Whether the entity is enabled. Set to 'no' to disable without deleting the entity. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "large_failure_ratio",
+      null,
+      null,
+      "[factor] Each unit using the N-1 failure method will have a separate constraint to require sufficient reserve to cover a failure of the unit generation (multiplied by this ratio). Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "max_share",
+      null,
+      null,
+      "[factor] Maximum ratio for the transfer of reserve to this node. Constant.",
+      "reserve"
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "reliability",
+      1.0,
+      null,
+      "[factor] The share of the reservation that is counted to reserves (sometimes reserve sources are not fully trusted). Constant.",
+      "reserve"
+    ],
+    [
+      "solve",
+      "benders_in_out_weight",
+      0.0,
+      null,
+      "Benders decomposition: in-out separation stabilization weight (lambda) in f_sep = lambda*centre + (1-lambda)*f_out. 0.0 (default) = off (exact Benders); values in (0,1) turn it on, larger = more stabilization. Only used when decomposition = 'benders'. Default 0.0.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "benders_max_iter",
+      50.0,
+      null,
+      "Benders decomposition: maximum number of outer (master/subproblem) iterations. Only used when decomposition = 'benders'. Default 50.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "benders_tolerance",
+      0.001,
+      null,
+      "Benders decomposition: relative optimality-gap tolerance (best_UB - LB)/|best_UB| for convergence of the outer loop. Only used when decomposition = 'benders'. Default 0.001.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "contains_solves",
+      null,
+      null,
+      "Array of solves - used for nested solve sequencesArray of solves - used for nested solve sequences",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "decomposition",
+      "none",
+      "decomposition_schemes",
+      "Decomposition scheme for this solve. 'none' (default) solves monolithically. 'benders' runs the solve through the Benders region-decomposition driver (a master trade layer coordinating per-region recourse subproblems via appended optimality cuts, producing a valid lower bound) over the groups whose group.decomposition_method is 'benders_regional' (requires at least two such region groups). The choice is per solve, so an investment solve can decompose while a later dispatch solve in the same chain stays monolithic.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "fix_storage_periods",
+      null,
+      null,
+      "Array of periods where the storage_values are fixed when the node has storage_include_solve_fix_method is set",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "invest_periods",
+      null,
+      null,
+      "Array of periods where investments are allowed.",
+      "solve_basics"
+    ],
+    [
+      "solve",
+      "new_stepduration",
+      null,
+      null,
+      "Hours. Creates a new `timeline` from the old for this `solve` with this timestep duration. The new timeline will sum or average the other timeseries data like `profile` and `inflow` for the new timesteps.",
+      "timeline"
+    ],
+    [
+      "solve",
+      "period_timeset",
+      null,
+      null,
+      "Map of periods with associated timesets that will be included in the solve. Index: period name, value: timeset name.",
+      "solve_basics"
+    ],
+    [
+      "solve",
+      "realized_invest_periods",
+      null,
+      null,
+      "Array of the periods that will realize the investment decisions. If not used when the invest_periods exist. The realized_periods are used to realize invests as well",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "realized_periods",
+      null,
+      null,
+      "Array of periods that will be realized in the solve.",
+      "solve_basics"
+    ],
+    [
+      "solve",
+      "rolling_duration",
+      null,
+      null,
+      "Hours (Optional). Duration of rolling, if not stated, assumed to be the whole timeline of the solve",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "rolling_solve_horizon",
+      null,
+      null,
+      "Hours (Required if rolling_window solve). How long into the future the roll sees",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "rolling_solve_jump",
+      null,
+      null,
+      "Hours, (Required if rolling_window solve). Interval between the start points of the rolls. Should be smaller than the horizon",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "scaling",
+      "full",
+      "scaling_modes",
+      "Numerical LP-autoscaler mode for this solve. 'full' (default) runs Layer 1 (detection) + Layer 2 (per-quantity-type column/row/cost rescaling) + Layer 3 (HiGHS user_*_scale). 'basic' drops Layer 2 (Layer 1 + Layer 3 only); 'solver_only' leaves scaling to the solver; 'off' disables all scaling including HiGHS-internal. Use 'basic' (or lower) for models whose Layer-2 rescaling mis-solves. The run-time --scaling flag / FLEXTOOL_SCALING env override this per-solve value.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "solve_mode",
+      "single_solve",
+      "solve_mode",
+      "A single_solve or rolling_window for a set of rolling optimisation windows solved in a sequence.",
+      "solve_basics"
+    ],
+    [
+      "solve",
+      "solver",
+      "highs",
+      "solvers",
+      "Solver to use for this solve. One of polar-high's available_solvers ('highs', 'gurobi', 'cplex', 'xpress', 'copt'). HiGHS is the bundled default; commercial solvers require a separate install and license.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "solver_arguments",
+      null,
+      null,
+      "Map of HiGHS solver options (option name -> value), layered on top of the floor values in solver_config/highs.opt and below any CLI overrides (e.g. --solver-time-limit). Use this for ad-hoc HiGHS knobs that do not have a dedicated FlexTool parameter (solver_mip_gap, solver_precommand).",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "solver_mip_gap",
+      null,
+      null,
+      "Relative MIP optimality gap at which the solver may stop early. Normalised across solvers by polar-high. None = solver default.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "solver_precommand",
+      null,
+      null,
+      "Additional command to execute before calling the solver. Can be used to e.g. reserve a floating license for a commercial solver.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "stochastic_branches",
+      null,
+      null,
+      "[4d-Map], Sets branches included in the solve. [Period, branch, start_time (time_step), realized (yes/no), weight (number)]. Only one of the branches should be realized for each start_time",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "timeline_hole_multiplier",
+      1.0,
+      null,
+      "[unitless] Multiplier applied to the inverse-step-duration term in nodeBalance_eq and storage-binding constraints across timeline gaps (holes).  Tunes how strongly state differences are penalised across discontinuities in the timeline.  Default 1.0 mirrors the .mod default and matches pre-v44 Python-convention behaviour.",
+      "solve_advanced"
+    ],
+    [
+      "solve",
+      "years_represented",
+      null,
+      null,
+      "Map to indicate how many years the period represents before the next period in the solve. Used for discounting. Can be below one (multiple periods in one year). Index: period, value: years.",
+      "solve_basics"
+    ],
+    [
+      "timeline",
+      "timestep_duration",
+      null,
+      null,
+      "Map of time steps in the timeline. Index: time step name, value: time step duration in hours.",
+      "timeline"
+    ],
+    [
+      "timeset",
+      "representative_period_weights",
+      null,
+      null,
+      "Representative-period weighting map (rank-2 nested Map: base period start timestep -> representative period start timestep -> weight).  Created by the representative-periods preprocess tool; declares how much each representative period stands in for each base period.  Its presence enables RP-aware storage-binding ('*_blended_weights'); its absence silently downgrades those methods to the non-RP behaviour.  Mutually exclusive with 'timeset_weights' on the same timeset.",
+      "solve_advanced"
+    ],
+    [
+      "timeset",
+      "timeline",
+      null,
+      null,
+      "The name of the timeline that the timeset uses. (String)",
+      "timeline"
+    ],
+    [
+      "timeset",
+      "timeset_duration",
+      null,
+      null,
+      "Index: name of the the timestep that starts the timeset, value: duration of the block in timesteps. Defines the *selection*: which timesteps are in the solve and how many (this sets 'hours_in_solve'). Representativeness - each timestep's share of the year - is set separately by 'timeset_weights'.",
+      "timeline"
+    ],
+    [
+      "timeset",
+      "timeset_weights",
+      null,
+      null,
+      "Per-timestep weight map (index: timestep name, value: float) defining *representativeness*: each timestep's share of the year. Drives the annualisation of demand, energy, and cost alike (the inflow scaling, the annual energy outputs, and the operating-cost objective all use this same weight), so the energy the model is scaled to serve, reports, and costs all coincide. Use for non-RP models where timesteps represent unequal fractions of the year (e.g. seasonal yearsplit on a coarse timeslice structure). Weights are normalized per period to sum to 1 and then scaled by the number of active timesteps so that uniform input reproduces the default (weight = 1 per step). Must not be combined with representative_period_weights on the same timeset.",
+      "timeline"
+    ],
+    [
+      "unit",
+      "availability",
+      1.0,
+      null,
+      "[e.g. 0.9 means 90%] Fraction of capacity available for flows from/to the unit. For online units, the online variable is multiplied by the availability. Constant, period, time, period+time or stochastic time.",
+      "basics"
+    ],
+    [
+      "unit",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places the cumulative pre-built capacity at period d — data baseline plus every v_invest made in periods strictly BEFORE d, retirements ignored — on the left side of the user-defined constraint. Enables learning-effect and period-over-period growth limits. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "unit",
+      "constraint_invested_capacity_coeff",
+      null,
+      null,
+      "A map of coefficients (index: constraint name, value: coefficient) that places v_invest[e, d] — new-build capacity decided in the current period — on the left side of the user-defined constraint. Not multiplied by unitsize.",
+      "constraint"
+    ],
+    [
+      "unit",
+      "conversion_method",
+      "constant_efficiency",
+      "conversion_methods",
+      "Choice of conversion method.",
+      "basics"
+    ],
+    [
+      "unit",
+      "cumulative_max_capacity",
+      null,
+      null,
+      "[MW] Maximum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "cumulative_min_capacity",
+      null,
+      null,
+      "[MW] Minimum cumulative capacity (considers existing, invested and retired capacity). Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "delay",
+      null,
+      null,
+      "[hours] A time delay between the input nodes and the output nodes. Either a constant indicating the time difference in hours or a map of time differences (index: time difference in hours, value: weight). Each weight indicates its share of the original flow and the weights should sum to 1. Requires that the time resolutions in the model are always integer multiples of these time differences.",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "discount_rate",
+      0.05,
+      null,
+      "[e.g. 0.05 equals 5%] Discount rate for investments (WACC). Reflects the financing cost and risk premium for this technology. When the model inflation_rate > 0, this should be a nominal rate. When inflation_rate = 0, this should be a real rate. Used to annualize investment costs over the lifetime. Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "efficiency",
+      1.0,
+      null,
+      "[factor] Efficiency of a unit. Constant, time or stochastic time.",
+      "basics"
+    ],
+    [
+      "unit",
+      "efficiency_at_min_load",
+      null,
+      null,
+      "[e.g. 0.4 means 40%] Efficiency of the unit at minimum load. Applies only if the unit has an online variable. Constant.",
+      "basics"
+    ],
+    [
+      "unit",
+      "existing",
+      null,
+      null,
+      "[MW] Existing capacity. Constant or period.",
+      "basics"
+    ],
+    [
+      "unit",
+      "fixed_cost",
+      null,
+      null,
+      "[CUR/kW] Annual fixed cost. Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_cost",
+      null,
+      null,
+      "[CUR/kW] Investment cost of the unit. Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_max_period",
+      null,
+      null,
+      "[MW] Maximum investment. Period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_max_total",
+      null,
+      null,
+      "[MW] Maximum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_method",
+      "not_allowed",
+      "invest_methods",
+      "Choice of investment method: not_allowed, invest and retire indicate availability of investment and retirement. no_limit removes all limits even if there are limiting values set. period uses values set in invest/retire_max/min_period. total uses values set in invest/retire_max/min_total.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_min_period",
+      null,
+      null,
+      "[MW] Minimum investment. Period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "invest_min_total",
+      null,
+      null,
+      "[MW] Minimum investment over all solves. Constant.",
+      "investment"
+    ],
+    [
+      "unit",
+      "lifetime",
+      null,
+      null,
+      "[years] Used to calculate annuity together with interest rate. Constant or period.",
+      "investment"
+    ],
+    [
+      "unit",
+      "lifetime_method",
+      "reinvest_automatic",
+      "lifetime_methods",
+      "Choice how the investments behave after unit runs out of lifetime. Automatic reinvestment causes the model to keep the capacity until the end of model horizon and applies the annualized investment cost without further model choice. Choice of reinvestment removes the capacity at the end of the lifetime and the model needs to decide how much new capacity is to be built.",
+      "investment"
+    ],
+    [
+      "unit",
+      "min_downtime",
+      null,
+      null,
+      "[hours] Minimum time the unit must stay offline after shutting down. Requires minimum_time_method set to 'min_downtime' or 'both'. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "min_load",
+      null,
+      null,
+      "[0-1] Minimum load of the unit. Applies only if the unit has an online variable. With linear startups, it is the share of capacity started up. Constant, time or stochastic time.",
+      "basics"
+    ],
+    [
+      "unit",
+      "min_uptime",
+      null,
+      null,
+      "[hours] Minimum time the unit must stay online after starting up. Requires minimum_time_method set to 'min_uptime' or 'both'. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "minimum_time_method",
+      null,
+      "minimum_time_methods",
+      "Choice between minimum up- and downtimes (none, min_downtime, min_uptime, both). Setting this to anything other than 'none' will activate online variables (at least linear) for the unit. Default: none (no minimum time constraints).",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "retire_max_period",
+      null,
+      null,
+      "[MW] Maximum retired capacity. Period.",
+      "retirement"
+    ],
+    [
+      "unit",
+      "retire_max_total",
+      null,
+      null,
+      "[MW] Maximum retired capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "unit",
+      "retire_min_period",
+      null,
+      null,
+      "[MW] Minimum retired capacity. Period.",
+      "retirement"
+    ],
+    [
+      "unit",
+      "retire_min_total",
+      null,
+      null,
+      "[MW] Minimum retired capacity over all solves. Constant.",
+      "retirement"
+    ],
+    [
+      "unit",
+      "salvage_value",
+      null,
+      null,
+      "[CUR/kW] Salvage value of the unit. Constant or period.",
+      "retirement"
+    ],
+    [
+      "unit",
+      "startup_cost",
+      null,
+      null,
+      "[CUR/MW] Cost of starting up one MW of 'virtual' capacity. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "startup_method",
+      "no_startup",
+      "startup_methods",
+      "Choice of startup method. Linear startup means that the unit can start partially (anything between 0 and full capacity) but will face startup cost as well as minimum load limit based on the capacity started up. Binary startup means that the unit is either off or fully on, but it is computationally more demanding than linearized startups.",
+      "tech_advanced"
+    ],
+    [
+      "unit",
+      "virtual_unitsize",
+      null,
+      null,
+      "[MW] Size of a single unit - used for integer investments (lumped investments), minimum loads and start-up costs. If not given, assumed from the existing unit capacity.",
+      "basics"
+    ],
+    [
+      "unit__inputNode",
+      "capacity_max_coeff",
+      1.0,
+      null,
+      "[factor, default 1.0] Fraction of the unit's capacity available to this edge's upper cap (maxToSink / maxFromSource / ramp). For extraction CHP set to 1.0 on each output so each can reach full capacity when the other drops.",
+      "basics"
+    ],
+    [
+      "unit__inputNode",
+      "capacity_min_coeff",
+      1.0,
+      null,
+      "[factor, default 1.0] Fraction of the unit's capacity imposed as a lower cap on this edge when online (combined multiplicatively with the unit-level min_load). Set to 0 to remove the lower cap on this edge (e.g. heat output of an extraction CHP that may drop to zero in pure-condensing mode).",
+      "basics"
+    ],
+    [
+      "unit__inputNode",
+      "constraint_flow_coeff",
+      null,
+      null,
+      "A map of coefficients (Index: constraint name, value: coefficient) to represent the participation of the flow between unit and node in user-defined constraints. [flow x coefficient] will be on the left side of the equation.",
+      "constraint"
+    ],
+    [
+      "unit__inputNode",
+      "conversion_flow_coeff",
+      1.0,
+      null,
+      "[factor] Energy-unit conversion factor for this flow in the node balance and conversion_indirect equations. Value of 0 removes the edge from capacity / ramp / min-load constraints entirely (hydro-pass-through pattern).",
+      "basics"
+    ],
+    [
+      "unit__inputNode",
+      "inertia_constant",
+      null,
+      null,
+      "[MWs/MW] Inertia constant for a synchronously connected unit to this node. Constant.",
+      "network"
+    ],
+    [
+      "unit__inputNode",
+      "is_non_synchronous",
+      "no",
+      "yes_no",
+      "Chooses whether the unit is synchronously connected to this node.",
+      "network"
+    ],
+    [
+      "unit__inputNode",
+      "other_operational_cost",
+      null,
+      null,
+      "[CUR/MWh] Other operational variable cost for energy flows. Constant, period, time, period+time or stochastic time.",
+      "basics"
+    ],
+    [
+      "unit__inputNode",
+      "ramp_cost",
+      null,
+      null,
+      "[CUR/MW] Cost of ramping the unit. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit__inputNode",
+      "ramp_method",
+      "none",
+      "ramp_methods",
+      "Choice of ramp method. 'ramp_limit' poses a limit on the speed of ramp. 'ramp_cost' poses a cost on ramping the flow (NOT FUNCTIONAL AS OF 19.3.2023).",
+      "tech_advanced"
+    ],
+    [
+      "unit__inputNode",
+      "ramp_speed_down",
+      null,
+      null,
+      "[per unit / minute] Maximum ramp down speed. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit__inputNode",
+      "ramp_speed_up",
+      null,
+      null,
+      "[per unit / minute] Maximum ramp up speed. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit__node__profile",
+      "profile_method",
+      "upper_limit",
+      "profile_methods",
+      "Choice of profile method (upper_limit, lower_limit, fixed). Negative values also possible.\n",
+      "basics"
+    ],
+    [
+      "unit__outputNode",
+      "capacity_max_coeff",
+      1.0,
+      null,
+      "[factor, default 1.0] Fraction of the unit's capacity available to this edge's upper cap (maxToSink / maxFromSource / ramp). For extraction CHP set to 1.0 on each output so each can reach full capacity when the other drops.",
+      "basics"
+    ],
+    [
+      "unit__outputNode",
+      "capacity_min_coeff",
+      1.0,
+      null,
+      "[factor, default 1.0] Fraction of the unit's capacity imposed as a lower cap on this edge when online (combined multiplicatively with the unit-level min_load). Set to 0 to remove the lower cap on this edge (e.g. heat output of an extraction CHP that may drop to zero in pure-condensing mode).",
+      "basics"
+    ],
+    [
+      "unit__outputNode",
+      "constraint_flow_coeff",
+      null,
+      null,
+      "A map of coefficients (Index: constraint name, value: coefficient) to represent the participation of the flow between unit and node in user-defined constraints. [flow x coefficient] will be on the left side of the equation.",
+      "constraint"
+    ],
+    [
+      "unit__outputNode",
+      "conversion_flow_coeff",
+      1.0,
+      null,
+      "[factor] Energy-unit conversion factor for this flow in the node balance and conversion_indirect equations. Value of 0 removes the edge from capacity / ramp / min-load constraints entirely (hydro-pass-through pattern).",
+      "basics"
+    ],
+    [
+      "unit__outputNode",
+      "inertia_constant",
+      null,
+      null,
+      "[MWs/MW] Inertia constant for a synchronously connected unit to this node. Constant.",
+      "network"
+    ],
+    [
+      "unit__outputNode",
+      "is_non_synchronous",
+      "no",
+      "yes_no",
+      "Chooses whether the unit is synchronously connected to this node.",
+      "network"
+    ],
+    [
+      "unit__outputNode",
+      "other_operational_cost",
+      null,
+      null,
+      "[CUR/MWh] Other operational variable cost for energy flows. Constant, period, time, period+time or stochastic time.",
+      "basics"
+    ],
+    [
+      "unit__outputNode",
+      "ramp_cost",
+      null,
+      null,
+      "[CUR/MW] Cost of ramping the unit. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit__outputNode",
+      "ramp_method",
+      "none",
+      "ramp_methods",
+      "Choice of ramp methods.",
+      "tech_advanced"
+    ],
+    [
+      "unit__outputNode",
+      "ramp_speed_down",
+      null,
+      null,
+      "[per unit  / minute] Maximum ramp down speed. Constant.",
+      "tech_advanced"
+    ],
+    [
+      "unit__outputNode",
+      "ramp_speed_up",
+      null,
+      null,
+      "[per unit  / minute] Maximum ramp up speed. Constant.",
+      "tech_advanced"
+    ]
+  ],
+  "parameter_types": [
+    [
+      "commodity",
+      "co2_content",
+      "float",
+      0
+    ],
+    [
+      "commodity",
+      "price",
+      "float",
+      0
+    ],
+    [
+      "commodity",
+      "price",
+      "map",
+      1
+    ],
+    [
+      "commodity",
+      "price_ladder_annual",
+      "map",
+      2
+    ],
+    [
+      "commodity",
+      "price_ladder_annual",
+      "map",
+      3
+    ],
+    [
+      "commodity",
+      "price_ladder_cumulative",
+      "map",
+      2
+    ],
+    [
+      "commodity",
+      "price_method",
+      "str",
+      0
+    ],
+    [
+      "commodity",
+      "unitsize",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "availability",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "availability",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "availability",
+      "map",
+      2
+    ],
+    [
+      "connection",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "constraint_invested_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "cumulative_max_capacity",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "cumulative_max_capacity",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "cumulative_min_capacity",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "cumulative_min_capacity",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "delay",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "delay",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "discount_rate",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "discount_rate",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "efficiency",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "efficiency",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "existing",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "existing",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "fixed_cost",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "fixed_cost",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "invest_cost",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "invest_cost",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "invest_max_period",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "invest_max_total",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "invest_method",
+      "str",
+      0
+    ],
+    [
+      "connection",
+      "invest_min_period",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "invest_min_total",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "is_DC",
+      "str",
+      0
+    ],
+    [
+      "connection",
+      "lifetime",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "lifetime",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "lifetime_method",
+      "str",
+      0
+    ],
+    [
+      "connection",
+      "other_operational_cost",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "other_operational_cost",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "other_operational_cost",
+      "map",
+      2
+    ],
+    [
+      "connection",
+      "reactance",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "retire_max_period",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "retire_max_total",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "retire_min_period",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "retire_min_total",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "salvage_value",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "salvage_value",
+      "map",
+      1
+    ],
+    [
+      "connection",
+      "startup_cost",
+      "float",
+      0
+    ],
+    [
+      "connection",
+      "startup_method",
+      "str",
+      0
+    ],
+    [
+      "connection",
+      "transfer_method",
+      "str",
+      0
+    ],
+    [
+      "connection",
+      "virtual_unitsize",
+      "float",
+      0
+    ],
+    [
+      "connection__node",
+      "constraint_flow_coeff",
+      "map",
+      1
+    ],
+    [
+      "connection__profile",
+      "profile_method",
+      "str",
+      0
+    ],
+    [
+      "constraint",
+      "constant",
+      "float",
+      0
+    ],
+    [
+      "constraint",
+      "is_enabled",
+      "str",
+      0
+    ],
+    [
+      "constraint",
+      "sense",
+      "str",
+      0
+    ],
+    [
+      "flowGroup",
+      "flow_aggregator",
+      "str",
+      0
+    ],
+    [
+      "flowGroup",
+      "max_cumulative_flow",
+      "float",
+      0
+    ],
+    [
+      "flowGroup",
+      "max_cumulative_flow",
+      "map",
+      1
+    ],
+    [
+      "flowGroup",
+      "max_instant_flow",
+      "float",
+      0
+    ],
+    [
+      "flowGroup",
+      "max_instant_flow",
+      "map",
+      1
+    ],
+    [
+      "flowGroup",
+      "max_instant_flow",
+      "map",
+      2
+    ],
+    [
+      "flowGroup",
+      "min_cumulative_flow",
+      "float",
+      0
+    ],
+    [
+      "flowGroup",
+      "min_cumulative_flow",
+      "map",
+      1
+    ],
+    [
+      "flowGroup",
+      "min_instant_flow",
+      "float",
+      0
+    ],
+    [
+      "flowGroup",
+      "min_instant_flow",
+      "map",
+      1
+    ],
+    [
+      "flowGroup",
+      "min_instant_flow",
+      "map",
+      2
+    ],
+    [
+      "group",
+      "base_MVA",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "candidate_precapacity_to_avoid_big_m",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "capacity_margin",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "capacity_margin",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "co2_max_period",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "co2_max_total",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "co2_method",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "co2_price",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "co2_price",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "co2_price",
+      "map",
+      2
+    ],
+    [
+      "group",
+      "cumulative_max_capacity",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "cumulative_max_capacity",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "cumulative_min_capacity",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "cumulative_min_capacity",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "decomposition_method",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "has_inertia",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "has_non_synchronous",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "include_stochastics",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "inertia_limit",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "inertia_limit",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "invest_max_period",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "invest_max_total",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "invest_method",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "invest_min_period",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "invest_min_total",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "new_stepduration",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "non_synchronous_limit",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "non_synchronous_limit",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "penalty_capacity_margin",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "penalty_capacity_margin",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "penalty_inertia",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "penalty_inertia",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "penalty_non_synchronous",
+      "float",
+      0
+    ],
+    [
+      "group",
+      "penalty_non_synchronous",
+      "map",
+      1
+    ],
+    [
+      "group",
+      "print_dispatch",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "print_indicators",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "reference_node",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "share_loss_of_load",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "transfer_method",
+      "str",
+      0
+    ],
+    [
+      "group",
+      "use_for_representative_periods",
+      "str",
+      0
+    ],
+    [
+      "model",
+      "inflation_offset_investment",
+      "float",
+      0
+    ],
+    [
+      "model",
+      "inflation_offset_operations",
+      "float",
+      0
+    ],
+    [
+      "model",
+      "inflation_rate",
+      "float",
+      0
+    ],
+    [
+      "model",
+      "max_flow_for_unconstrained_variables",
+      "float",
+      0
+    ],
+    [
+      "model",
+      "output_horizon",
+      "str",
+      0
+    ],
+    [
+      "model",
+      "periods_available",
+      "array",
+      1
+    ],
+    [
+      "model",
+      "small_number_threshold",
+      "float",
+      0
+    ],
+    [
+      "model",
+      "solves",
+      "array",
+      1
+    ],
+    [
+      "model",
+      "version",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "annual_flow",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "annual_flow",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "availability",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "availability",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "availability",
+      "map",
+      2
+    ],
+    [
+      "node",
+      "availability",
+      "map",
+      3
+    ],
+    [
+      "node",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "constraint_invested_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "constraint_state_coeff",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "cumulative_max_capacity",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "cumulative_max_capacity",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "cumulative_min_capacity",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "cumulative_min_capacity",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "discount_rate",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "discount_rate",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "existing",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "existing",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "fixed_cost",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "fixed_cost",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "inflow",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "inflow",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "inflow",
+      "map",
+      3
+    ],
+    [
+      "node",
+      "inflow_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "invest_cost",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "invest_cost",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "invest_forced",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "invest_forced",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "invest_max_period",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "invest_max_total",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "invest_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "invest_min_period",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "invest_min_total",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "lifetime",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "lifetime",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "lifetime_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "node_type",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "peak_inflow",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "peak_inflow",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "penalty_down",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "penalty_down",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "penalty_down",
+      "map",
+      2
+    ],
+    [
+      "node",
+      "penalty_down",
+      "map",
+      3
+    ],
+    [
+      "node",
+      "penalty_up",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "penalty_up",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "penalty_up",
+      "map",
+      2
+    ],
+    [
+      "node",
+      "penalty_up",
+      "map",
+      3
+    ],
+    [
+      "node",
+      "retire_max_period",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "retire_max_total",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "retire_min_period",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "retire_min_total",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "salvage_value",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "salvage_value",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "self_discharge_loss",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "self_discharge_loss",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "storage_binding_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "storage_nested_fix_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "storage_solve_horizon_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "storage_start_end_method",
+      "str",
+      0
+    ],
+    [
+      "node",
+      "storage_state_end",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "storage_state_reference_price",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "storage_state_reference_price",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "storage_state_reference_value",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "storage_state_reference_value",
+      "map",
+      1
+    ],
+    [
+      "node",
+      "storage_state_reference_value",
+      "map",
+      2
+    ],
+    [
+      "node",
+      "storage_state_start",
+      "float",
+      0
+    ],
+    [
+      "node",
+      "virtual_unitsize",
+      "float",
+      0
+    ],
+    [
+      "node__profile",
+      "profile_method",
+      "str",
+      0
+    ],
+    [
+      "profile",
+      "profile",
+      "map",
+      1
+    ],
+    [
+      "profile",
+      "profile",
+      "map",
+      3
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "increase_reserve_ratio",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "is_enabled",
+      "str",
+      0
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "large_failure_ratio",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "max_share",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__connection__node",
+      "reliability",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__group",
+      "increase_reserve_ratio",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__group",
+      "penalty_reserve",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__group",
+      "reservation",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__group",
+      "reservation",
+      "map",
+      1
+    ],
+    [
+      "reserve__upDown__group",
+      "reservation",
+      "map",
+      2
+    ],
+    [
+      "reserve__upDown__group",
+      "reservation",
+      "map",
+      3
+    ],
+    [
+      "reserve__upDown__group",
+      "reserve_method",
+      "str",
+      0
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "increase_reserve_ratio",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "is_enabled",
+      "str",
+      0
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "large_failure_ratio",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "max_share",
+      "float",
+      0
+    ],
+    [
+      "reserve__upDown__unit__node",
+      "reliability",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "benders_in_out_weight",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "benders_max_iter",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "benders_tolerance",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "contains_solves",
+      "array",
+      1
+    ],
+    [
+      "solve",
+      "contains_solves",
+      "str",
+      0
+    ],
+    [
+      "solve",
+      "decomposition",
+      "str",
+      0
+    ],
+    [
+      "solve",
+      "fix_storage_periods",
+      "array",
+      1
+    ],
+    [
+      "solve",
+      "fix_storage_periods",
+      "map",
+      2
+    ],
+    [
+      "solve",
+      "invest_periods",
+      "array",
+      1
+    ],
+    [
+      "solve",
+      "invest_periods",
+      "map",
+      2
+    ],
+    [
+      "solve",
+      "new_stepduration",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "period_timeset",
+      "map",
+      1
+    ],
+    [
+      "solve",
+      "realized_invest_periods",
+      "array",
+      1
+    ],
+    [
+      "solve",
+      "realized_invest_periods",
+      "map",
+      2
+    ],
+    [
+      "solve",
+      "realized_periods",
+      "array",
+      1
+    ],
+    [
+      "solve",
+      "realized_periods",
+      "map",
+      2
+    ],
+    [
+      "solve",
+      "rolling_duration",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "rolling_solve_horizon",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "rolling_solve_jump",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "solve_mode",
+      "str",
+      0
+    ],
+    [
+      "solve",
+      "solver",
+      "str",
+      0
+    ],
+    [
+      "solve",
+      "solver_arguments",
+      "map",
+      1
+    ],
+    [
+      "solve",
+      "solver_mip_gap",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "solver_precommand",
+      "str",
+      0
+    ],
+    [
+      "solve",
+      "stochastic_branches",
+      "map",
+      4
+    ],
+    [
+      "solve",
+      "timeline_hole_multiplier",
+      "float",
+      0
+    ],
+    [
+      "solve",
+      "years_represented",
+      "map",
+      1
+    ],
+    [
+      "timeline",
+      "timestep_duration",
+      "map",
+      1
+    ],
+    [
+      "timeset",
+      "representative_period_weights",
+      "map",
+      2
+    ],
+    [
+      "timeset",
+      "timeline",
+      "str",
+      0
+    ],
+    [
+      "timeset",
+      "timeset_duration",
+      "map",
+      1
+    ],
+    [
+      "timeset",
+      "timeset_weights",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "availability",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "availability",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "availability",
+      "map",
+      2
+    ],
+    [
+      "unit",
+      "availability",
+      "map",
+      3
+    ],
+    [
+      "unit",
+      "constraint_cumulative_pre_built_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "constraint_invested_capacity_coeff",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "conversion_method",
+      "str",
+      0
+    ],
+    [
+      "unit",
+      "cumulative_max_capacity",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "cumulative_max_capacity",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "cumulative_min_capacity",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "cumulative_min_capacity",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "delay",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "delay",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "discount_rate",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "discount_rate",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "efficiency",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "efficiency",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "efficiency",
+      "map",
+      3
+    ],
+    [
+      "unit",
+      "efficiency_at_min_load",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "existing",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "existing",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "fixed_cost",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "fixed_cost",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "invest_cost",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "invest_cost",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "invest_max_period",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "invest_max_total",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "invest_method",
+      "str",
+      0
+    ],
+    [
+      "unit",
+      "invest_min_period",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "invest_min_total",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "lifetime",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "lifetime",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "lifetime_method",
+      "str",
+      0
+    ],
+    [
+      "unit",
+      "min_downtime",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "min_load",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "min_load",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "min_load",
+      "map",
+      3
+    ],
+    [
+      "unit",
+      "min_uptime",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "minimum_time_method",
+      "str",
+      0
+    ],
+    [
+      "unit",
+      "retire_max_period",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "retire_max_total",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "retire_min_period",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "retire_min_total",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "salvage_value",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "salvage_value",
+      "map",
+      1
+    ],
+    [
+      "unit",
+      "startup_cost",
+      "float",
+      0
+    ],
+    [
+      "unit",
+      "startup_method",
+      "str",
+      0
+    ],
+    [
+      "unit",
+      "virtual_unitsize",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "capacity_max_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "capacity_min_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "constraint_flow_coeff",
+      "map",
+      1
+    ],
+    [
+      "unit__inputNode",
+      "conversion_flow_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "inertia_constant",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "is_non_synchronous",
+      "str",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "other_operational_cost",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "other_operational_cost",
+      "map",
+      1
+    ],
+    [
+      "unit__inputNode",
+      "other_operational_cost",
+      "map",
+      2
+    ],
+    [
+      "unit__inputNode",
+      "other_operational_cost",
+      "map",
+      3
+    ],
+    [
+      "unit__inputNode",
+      "ramp_cost",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "ramp_method",
+      "str",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "ramp_speed_down",
+      "float",
+      0
+    ],
+    [
+      "unit__inputNode",
+      "ramp_speed_up",
+      "float",
+      0
+    ],
+    [
+      "unit__node__profile",
+      "profile_method",
+      "str",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "capacity_max_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "capacity_min_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "constraint_flow_coeff",
+      "map",
+      1
+    ],
+    [
+      "unit__outputNode",
+      "conversion_flow_coeff",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "inertia_constant",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "is_non_synchronous",
+      "str",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "other_operational_cost",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "other_operational_cost",
+      "map",
+      1
+    ],
+    [
+      "unit__outputNode",
+      "other_operational_cost",
+      "map",
+      2
+    ],
+    [
+      "unit__outputNode",
+      "other_operational_cost",
+      "map",
+      3
+    ],
+    [
+      "unit__outputNode",
+      "ramp_cost",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "ramp_method",
+      "str",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "ramp_speed_down",
+      "float",
+      0
+    ],
+    [
+      "unit__outputNode",
+      "ramp_speed_up",
+      "float",
+      0
+    ]
+  ],
+  "alternatives": [
+    [
+      "base",
+      "Base alternative"
+    ]
+  ]
+}