Function bodies 99 total

def set_storage_speed_deck_a(value: int) -> str:
    _check_write()
    _validate_u8(value, "value")
    return _json(_client().set_function("SetStorageSpeedDeckA", value))

def set_storage_speed_deck_b(value: int) -> str:
    _check_write()
    _validate_u8(value, "value")
    return _json(_client().set_function("SetStorageSpeedDeckB", value))

def toggle_storage_speed_pause_deck_a() -> str:
    _check_write()
    return _json(_set_no_value("SetStorageSpeedPauseToggleDeckA"))

def toggle_storage_speed_pause_deck_b() -> str:
    _check_write()
    return _json(_set_no_value("SetStorageSpeedPauseToggleDeckB"))

def set_cuelist_select(index: int) -> str:
    _check_write()
    _validate_non_negative_int(index, "index")
    return _json(_client().set_function("SetCuelistSelect", index))

def cuelist_go() -> str:
    _check_write()
    return _json(_set_no_value("SetCuelistGo"))

def cuelist_back() -> str:
    _check_write()
    return _json(_set_no_value("SetCuelistBack"))

def set_audio_input_mute(enabled: bool) -> str:
    _check_write()
    return _json(_client().set_function("SetAudioInputMute", 1 if enabled else 0))

def toggle_audio_input_mute() -> str:
    _check_write()
    return _json(_set_no_value("SetAudioInputMuteToggle"))

def set_audio_input_fader(value: int) -> str:
    _check_write()
    _validate_u8(value, "value")
    return _json(_client().set_function("SetAudioInputFader", value))

def set_audio_output_mute(enabled: bool) -> str:
    _check_write()
    return _json(_client().set_function("SetAudioOutputMute", 1 if enabled else 0))

def toggle_audio_output_mute() -> str:
    _check_write()
    return _json(_set_no_value("SetAudioOutputMuteToggle"))

def set_audio_output_fader(value: int) -> str:
    _check_write()
    _validate_u8(value, "value")
    return _json(_client().set_function("SetAudioOutputFader", value))

def set_auto_gain_input(enabled: bool) -> str:
    _check_write()
    return _json(_client().set_function("SetAutoGainInput", 1 if enabled else 0))

def toggle_auto_gain_input() -> str:
    _check_write()
    return _json(_set_no_value("SetAutoGainInputToggle"))

def set_output_freeze(enabled: bool) -> str:
    _check_write()
    return _json(_client().set_function("SetOutputFreeze", 1 if enabled else 0))

def toggle_output_freeze() -> str:
    _check_write()
    return _json(_set_no_value("SetOutputFreezeToggle"))

def set_output_strobe(enabled: bool) -> str:
    _check_write()
    return _json(_client().set_function("SetOutputStrobe", 1 if enabled else 0))

def toggle_output_strobe() -> str:
    _check_write()
    return _json(_set_no_value("SetOutputStrobeToggle"))

def set_output_strobe_value(value: int) -> str:
    _check_write()
    _validate_u8(value, "value")
    return _json(_client().set_function("SetOutputStrobeValue", value))

def set_output_strobe_color(red: int, green: int, blue: int, white: int = 0) -> str:
    _check_write()
    _validate_u8(red, "red")
    _validate_u8(green, "green")
    _validate_u8(blue, "blue")
    _validate_u8(white, "white")
    client = _client()
    return _json({
        "red": client.set_function("SetOutputStrobeColorRed", red),
        "green": client.set_function("SetOutputStrobeColorGreen", green),
        "blue": client.set_function("SetOutputStrobeColorBlue", blue),
        "white": client.set_function("SetOutputStrobeColorWhite", white),
    })

def set_output_filter(level: int) -> str:
    _check_write()
    _validate_u8(level, "level")
    return _json(_client().set_function("SetOutputFilter", level))

def set_output_filter_color(red: int, green: int, blue: int, white: int = 0) -> str:
    _check_write()
    _validate_u8(red, "red")
    _validate_u8(green, "green")
    _validate_u8(blue, "blue")
    _validate_u8(white, "white")
    client = _client()
    return _json({
        "red": client.set_function("SetOutputFilterRed", red),
        "green": client.set_function("SetOutputFilterGreen", green),
        "blue": client.set_function("SetOutputFilterBlue", blue),
        "white": client.set_function("SetOutputFilterWhite", white),
    })

def set_text_ticker(text: str) -> str:
    _check_write()
    _validate_string_non_empty(text, "text")
    return _json(_client().set_function("SetTextTicker", text))

def set_bpm(value: int) -> str:
    _check_write()
    _validate_non_negative_int(value, "value")
    return _json(_client().set_function("SetBpm", value))

def get_preview_info() -> str:
    config = load_config()
    return _json({
        "deck_a_bitmap_url": f"{config.base_url}?GetPreviewDeckA.bmp",
        "deck_b_bitmap_url": f"{config.base_url}?GetPreviewDeckB.bmp",
        "output_bitmap_url": f"{config.base_url}?GetPreviewOutput.bmp",
        "note": "Preview bitmap URLs are exposed directly because they are binary assets, not scalar text values.",
    })

def get_timeline_summary() -> str:
    client = _client()
    result = client.get_functions(
        [
            ("GetTimelinesSelected", None),
            ("GetTimelinesActive", None),
            ("GetTimelinesCount", None),
            ("GetTimelinesPlaybackState", None),
            ("GetTimelinesDuration", None),
        ]
    )
    lines = result["lines"]
    return _json({
        "selected": lines[0] if len(lines) > 0 else None,
        "active": lines[1] if len(lines) > 1 else None,
        "count": lines[2] if len(lines) > 2 else None,
        "playback_state": lines[3] if len(lines) > 3 else None,
        "duration": lines[4] if len(lines) > 4 else None,
        "raw": result,
    })

def get_group_summary(group_id: int) -> str:
    _validate_non_negative_int(group_id, "group_id")
    client = _client()
    result = client.get_functions(
        [
            ("GetGroupFadeTime", None),
            ("GetGroupCount", None),
            ("GetGroupDisplayName", str(group_id)),
            ("GetGroupDisplayColor", str(group_id)),
            ("GetGroupDefaultValue", str(group_id)),
            ("GetGroupFlashMode", str(group_id)),
            ("GetGroupValue", str(group_id)),
            ("GetGroupPresetDescription", str(group_id)),
            ("GetGroupPresetFullState", str(group_id)),
        ]
    )
    lines = result["lines"]
    return _json({
        "group_id": group_id,
        "fade_time": lines[0] if len(lines) > 0 else None,
        "count": lines[1] if len(lines) > 1 else None,
        "display_name": lines[2] if len(lines) > 2 else None,
        "display_color": lines[3] if len(lines) > 3 else None,
        "default_value": lines[4] if len(lines) > 4 else 

def get_global_color(color_id: int) -> str:
    _validate_non_negative_int(color_id, "color_id")
    client = _client()
    result = client.get_functions(
        [
            ("GetGlobalColorAvailable", str(color_id)),
            ("GetGlobalColorDescription", str(color_id)),
            ("GetGlobalColorRed", str(color_id)),
            ("GetGlobalColorGreen", str(color_id)),
            ("GetGlobalColorBlue", str(color_id)),
            ("GetGlobalColorWhite", str(color_id)),
            ("GetGlobalColorAlpha", str(color_id)),
            ("GetGlobalColorRGB", str(color_id)),
        ]
    )
    lines = result["lines"]
    return _json({
        "color_id": color_id,
        "available": lines[0] if len(lines) > 0 else None,
        "description": lines[1] if len(lines) > 1 else None,
        "red": lines[2] if len(lines) > 2 else None,
        "green": lines[3] if len(lines) > 3 else None,
        "blue": lines[4] if len(lines) > 4 else None,
        "white": lines[5] if len(lines)

def get_storage_place_details(storage: int, place: int) -> str:
    _validate_non_negative_int(storage, "storage")
    _validate_non_negative_int(place, "place")
    ref = f"S{storage}P{place}"
    client = _client()
    result = client.get_functions(
        [
            ("GetStoragePlaceDescription", ref),
            ("GetStoragePlaceFullState", ref),
            ("GetStoragePlaceThumbTimeStamp", ref),
        ]
    )
    lines = result["lines"]
    config = load_config()
    return _json({
        "storage": storage,
        "place": place,
        "reference": ref,
        "description": lines[0] if len(lines) > 0 else None,
        "full_state": lines[1] if len(lines) > 1 else None,
        "thumb_timestamp": lines[2] if len(lines) > 2 else None,
        "thumb_url": f"{config.base_url}?GetStoragePlaceThumb.png={ref}",
        "raw": result,
    })

def _create_deck_level_value_tool(*, tool_name: str, function_template: str, field_name: str, minimum: int, maximum: int):
    @_handle_errors
    def tool(deck: str, value: int) -> str:
        _validate_int_range(value, field_name, minimum=minimum, maximum=maximum)
        function_name = function_template.format(deck=_deck_suffix(deck))
        return _json(_client().set_function(function_name, value))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_deck_level_float_tool(*, tool_name: str, function_template: str, field_name: str, minimum: float):
    @_handle_errors
    def tool(deck: str, value: float) -> str:
        if value < minimum:
            raise ValueError(f"{field_name} must be >= {minimum}, got {value}")
        function_name = function_template.format(deck=_deck_suffix(deck))
        return _json(_client().set_function(function_name, value))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_layer_property_tool(*, tool_name: str, function_template: str, field_name: str, minimum: int, maximum: int):
    @_handle_errors
    def tool(deck: str, layer: int, value: int) -> str:
        _validate_layer_index(layer)
        _validate_int_range(value, field_name, minimum=minimum, maximum=maximum)
        function_name = function_template.format(deck=_deck_suffix(deck))
        return _json(_client().set_function(function_name, _underscore_pair(layer, value)))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} for a specific layer on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_current_layer_property_tool(*, tool_name: str, function_template: str, field_name: str, minimum: int, maximum: int):
    @_handle_errors
    def tool(deck: str, value: int) -> str:
        _validate_int_range(value, field_name, minimum=minimum, maximum=maximum)
        function_name = function_template.format(deck=_deck_suffix(deck))
        return _json(_client().set_function(function_name, value))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} for the current layer on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_exact_layer_property_tool(*, tool_name: str, function_template: str, field_name: str, minimum: int, maximum: int):
    @_handle_errors
    def tool(deck: str, layer: int, value: int) -> str:
        _validate_layer_index(layer)
        _validate_int_range(value, field_name, minimum=minimum, maximum=maximum)
        function_name = function_template.format(deck=_deck_suffix(deck), layer=f"{layer:02d}")
        return _json(_client().set_function(function_name, value))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} for a specific layer on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_layer_toggle_tool(*, tool_name: str, function_template: str, field_name: str):
    @_handle_errors
    def tool(deck: str, layer: int, enabled: bool) -> str:
        _validate_layer_index(layer)
        function_name = function_template.format(deck=_deck_suffix(deck), layer=f"{layer:02d}")
        return _json(_client().set_function(function_name, 1 if enabled else 0))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} for a specific layer on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def _create_current_layer_toggle_tool(*, tool_name: str, function_template: str, field_name: str):
    @_handle_errors
    def tool(deck: str, enabled: bool) -> str:
        function_name = function_template.format(deck=_deck_suffix(deck))
        return _json(_client().set_function(function_name, 1 if enabled else 0))

    tool.__name__ = tool_name
    tool.__doc__ = f"Set {field_name} for the current layer on deck A or B."
    globals()[tool_name] = mcp.tool()(tool)

def set_timelines_playback_state(state: int) -> str:
    _validate_int_range(state, "state", minimum=0, maximum=2)
    return _json(_client().set_function("SetTimelinesPlaybackState", state))

def set_cuelist_timecode_source(source: int) -> str:
    _validate_int_range(source, "source", minimum=0, maximum=4)
    _check_write()
    return _json(_client().set_function("SetCuelistTimeCodeSource", source))

def set_cuelist_playback_mode(mode: int) -> str:
    _validate_int_range(mode, "mode", minimum=0, maximum=1)
    _check_write()
    return _json(_client().set_function("SetCuelistPlaybackMode", mode))

def set_cuelist_fade_type(cue_index: int, fade_type: str) -> str:
    if fade_type not in _FADE_TYPES and fade_type not in {str(i) for i in range(15)}:
        raise ValueError(f"fade_type must be one of {sorted(_FADE_TYPES)} or the string numbers 0-14, got {fade_type!r}")
    return _json(_set_pair_string("SetCuelistFadeType", "cue_index", cue_index, "fade_type", fade_type))

def set_cuelist_fade_time(cue_index: int, seconds: float) -> str:
    if seconds < 0:
        raise ValueError(f"seconds must be >= 0, got {seconds}")
    _validate_non_negative_int(cue_index, "cue_index")
    _check_write()
    return _json(_client().set_function("SetCuelistFadeTime", _underscore_pair(cue_index, seconds)))

def set_global_color_channel(color_id: int, channel: str, value: int) -> str:
    _validate_non_negative_int(color_id, "color_id")
    _validate_u8(value, "value")
    normalized = channel.strip().lower()
    mapping = {
        "red": "SetGlobalColorRed",
        "green": "SetGlobalColorGreen",
        "blue": "SetGlobalColorBlue",
        "white": "SetGlobalColorWhite",
        "alpha": "SetGlobalColorAlpha",
    }
    if normalized not in mapping:
        raise ValueError(f"channel must be one of {sorted(mapping)}, got {channel!r}")
    _check_write()
    return _json(_client().set_function(mapping[normalized], _underscore_pair(color_id, value)))

def set_global_color(color_id: int, component_spec: str) -> str:
    _validate_non_negative_int(color_id, "color_id")
    _validate_string_non_empty(component_spec, "component_spec")
    _check_write()
    return _json(_client().set_function("SetGlobalColor", _underscore_pair(color_id, component_spec)))

def set_group_value(group_id: int, value: int) -> str:
    return _json(
        _set_pair_int(
            "SetGroupValue",
            "group_id",
            group_id,
            "value",
            value,
            second_validator=lambda v: _validate_u8(v, "value"),
        )
    )

def set_group_flash_mode(group_id: int, enabled: bool) -> str:
    _validate_non_negative_int(group_id, "group_id")
    _check_write()
    return _json(_client().set_function("SetGroupFlashMode", _underscore_pair(group_id, 1 if enabled else 0)))

def select_layer(deck: str, layer: int) -> str:
    _validate_layer_index(layer)
    function_name = f"SetLayer{_deck_suffix(deck)}"
    return _json(_client().set_function(function_name, layer))

def set_text_ticker_layer(deck: str, layer: int, text: str) -> str:
    _validate_layer_index(layer)
    _validate_string_non_empty(text, "text")
    function_name = f"SetTextTickerLayer{_deck_suffix(deck)}"
    return _json(_client().set_function(function_name, _underscore_pair(layer, text)))

def main() -> None:
    transport = os.getenv("MADRIX_TRANSPORT", "stdio").lower()
    if transport == "stdio":
        mcp.run()
        return
    if transport == "sse":
        mcp.run(transport="sse")
        return
    if transport == "streamable-http":
        mcp.run(transport="streamable-http")
        return
    raise ValueError("MADRIX_TRANSPORT must be one of: stdio, sse, streamable-http")