import api


############################################################
# ChangeSet
############################################################

ChangeSet = api.ChangeSet


############################################################
# enum
############################################################

JUNCTION = api.JUNCTION
RESERVOIR = api.RESERVOIR
TANK = api.TANK
PIPE = api.PIPE
PUMP = api.PUMP
VALVE = api.VALVE

OVERFLOW_YES = api.OVERFLOW_YES
OVERFLOW_NO = api.OVERFLOW_NO

PIPE_STATUS_OPEN = api.PIPE_STATUS_OPEN
PIPE_STATUS_CLOSED = api.PIPE_STATUS_CLOSED
PIPE_STATUS_CV = api.PIPE_STATUS_CV

VALVES_TYPE_PRV = api.VALVES_TYPE_PRV
VALVES_TYPE_PSV = api.VALVES_TYPE_PSV
VALVES_TYPE_PBV = api.VALVES_TYPE_PBV
VALVES_TYPE_FCV = api.VALVES_TYPE_FCV
VALVES_TYPE_TCV = api.VALVES_TYPE_TCV
VALVES_TYPE_GPV = api.VALVES_TYPE_GPV


############################################################
# project
############################################################

def have_project(name: str) -> bool:
    return api.have_project(name)

def create_project(name: str) -> None:
    return api.create_project(name)

def delete_project(name: str) -> None:
    return api.delete_project(name)

def is_project_open(name: str) -> bool:
    return api.is_project_open(name)

def open_project(name: str) -> None:
    return api.open_project(name)

def close_project(name: str) -> None:
    return api.close_project(name)

def copy_project(source: str, new: str) -> None:
    return api.copy_project(source, new)


############################################################
# operation
############################################################

def undo(name: str) -> None:
    return api.undo(name)

def redo(name: str) -> None:
    return api.redo(name)

def have_snapshot(name: str, tag: str) -> bool:
    return api.have_snapshot(name, tag)

def take_snapshot(name: str, tag: str) -> None:
    return api.take_snapshot(name, tag)

def pick_snapshot(name: str, tag: str) -> None:
    return api.pick_snapshot(name, tag)

def have_transaction(name: str) -> bool:
    return api.have_transaction(name)

def start_transaction(name: str, strict: bool = False) -> None:
    return api.start_transaction(name, strict)

def commit_transaction(name: str) -> None:
    return api.commit_transaction(name)

def abort_transaction(name: str) -> None:
    return api.abort_transaction(name)


############################################################
# type
############################################################

def is_node(name: str, node_id: str) -> bool:
    return api.is_node(name, node_id)

def is_junction(name: str, node_id: str) -> bool:
    return api.is_junction(name, node_id)

def is_reservoir(name: str, node_id: str) -> bool:
    return api.is_reservoir(name, node_id)

def is_tank(name: str, node_id: str) -> bool:
    return api.is_tank(name, node_id)

def is_link(name: str, link_id: str) -> bool:
    return api.is_link(name, link_id)

def is_pipe(name: str, link_id: str) -> bool:
    return api.is_pipe(name, link_id)

def is_pump(name: str, link_id: str) -> bool:
    return api.is_pump(name, link_id)

def is_valve(name: str, link_id: str) -> bool:
    return api.is_valve(name, link_id)

def is_curve(name: str, curve_id: str) -> bool:
    return api.is_curve(name, curve_id)

def is_pattern(name: str, pattern_id: str) -> bool:
    return api.is_pattern(name, pattern_id)

def get_nodes(name: str) -> list[str]:
    return api.get_nodes(name)

def get_links(name: str) -> list[str]:
    return api.get_links(name)

def get_curves(name: str) -> list[str]:
    return api.get_curves(name)

def get_patterns(name: str) -> list[str]:
    return api.get_patterns(name)


############################################################
# title 1.[TITLE]
############################################################

def set_title(name: str, title: str) -> ChangeSet:
    return api.set_title(name, title)

def get_title(name: str) -> str:
    return api.get_title(name)


############################################################
# junction 2.[JUNCTIONS]
############################################################

def add_junction(name: str, junction_id: str, x: float, y: float, elevation: float) -> ChangeSet:
    return api.add_junction(name, junction_id, x, y, elevation)

def delete_junction(name: str, junction_id: str) -> ChangeSet:
    return api.delete_junction(name, junction_id)

def get_junction_elevation(name: str, junction_id: str) -> float | None:
    return api.get_junction_elevation(name, junction_id)

def get_junction_demand(name: str, junction_id: str) -> float | str | None:
    return api.get_junction_demand(name, junction_id)

def get_junction_pattern(name: str, junction_id: str) -> str | None:
    return api.get_junction_pattern(name, junction_id)

def get_junction_coord(name: str, junction_id: str) -> dict[str, float] | None:
    return api.get_junction_coord(name, junction_id)

def set_junction_elevation(name: str, junction_id: str, elevation: float) -> ChangeSet:
    return api.set_junction_elevation(name, junction_id, elevation)

def set_junction_demand(name: str, junction_id: str, demand: float) -> ChangeSet:
    return api.set_junction_demand(name, junction_id, demand)

def set_junction_pattern(name: str, junction_id: str, pattern: str) -> ChangeSet:
    return api.set_junction_pattern(name, junction_id, pattern)

def set_junction_coord(name: str, junction_id: str, x: float, y: float) -> ChangeSet:
    return api.set_junction_coord(name, junction_id, x, y)


############################################################
# reservoir 3.[RESERVOIRS]
############################################################

def add_reservoir(name: str, reservoir_id: str, x: float, y: float, head: float) -> ChangeSet:
    return api.add_reservoir(name, reservoir_id, x, y, head)

def delete_reservoir(name: str, reservoir_id: str) -> ChangeSet:
    return api.delete_reservoir(name, reservoir_id)

def get_reservoir_head(name: str, reservoir_id: str) -> float | None:
    return api.get_reservoir_head(name, reservoir_id)

def get_reservoir_pattern(name: str, reservoir_id: str) -> str | None:
    return api.get_reservoir_pattern(name, reservoir_id)

def get_reservoir_coord(name: str, reservoir_id: str) -> dict[str, float] | None:
    return api.get_reservoir_coord(name, reservoir_id)

def set_reservoir_head(name: str, reservoir_id: str, head: float) -> ChangeSet:
    return api.set_reservoir_head(name, reservoir_id, head)

def set_reservoir_pattern(name: str, reservoir_id: str, pattern: str) -> ChangeSet:
    return api.set_reservoir_pattern(name, reservoir_id, pattern)

def set_reservoir_coord(name: str, reservoir_id: str, x: float, y: float) -> ChangeSet:
    return api.set_reservoir_coord(name, reservoir_id, x, y)


############################################################
# tank 4.[TANKS]
############################################################

def add_tank(name: str, tank_id: str, x: float, y: float, elevation: float, init_level: float = 0, min_level: float = 0, max_level: float = 0, diameter: float = 0, min_vol: float = 0) -> ChangeSet:
    return api.add_tank(name, tank_id, x, y, elevation, init_level, min_level, max_level, diameter, min_vol)

def delete_tank(name: str, tank_id: str) -> ChangeSet:
    return api.delete_tank(name, tank_id)

def get_tank_elevation(name: str, tank_id: str) -> float | None:
    return api.get_tank_elevation(name, tank_id)

def get_tank_init_level(name: str, tank_id: str) -> float | None:
    return api.get_tank_init_level(name, tank_id)

def get_tank_min_level(name: str, tank_id: str) -> float | None:
    return api.get_tank_min_level(name, tank_id)

def get_tank_max_level(name: str, tank_id: str) -> float | None:
    return api.get_tank_max_level(name, tank_id)

def get_tank_diameter(name: str, tank_id: str) -> float | None:
    return api.get_tank_diameter(name, tank_id)

def get_tank_min_vol(name: str, tank_id: str) -> float | None:
    return api.get_tank_min_vol(name, tank_id)

def get_tank_vol_curve(name: str, tank_id: str) -> str | None:
    return api.get_tank_vol_curve(name, tank_id)

def get_tank_overflow(name: str, tank_id: str) -> str | None:
    return api.get_tank_overflow(name, tank_id)

def get_tank_coord(name: str, tank_id: str) -> dict[str, float] | None:
    return api.get_tank_coord(name, tank_id)

def set_tank_elevation(name: str, tank_id: str, elevation: float) -> ChangeSet:
    return api.set_tank_elevation(name, tank_id, elevation)

def set_tank_init_level(name: str, tank_id: str, init_level: float) -> ChangeSet:
    return api.set_tank_init_level(name, tank_id, init_level)

def set_tank_min_level(name: str, tank_id: str, min_level: float) -> ChangeSet:
    return api.set_tank_min_level(name, tank_id, min_level)

def set_tank_max_level(name: str, tank_id: str, max_level: float) -> ChangeSet:
    return api.set_tank_max_level(name, tank_id, max_level)

def set_tank_diameter(name: str, tank_id: str, diameter: float) -> ChangeSet:
    return api.set_tank_diameter(name, tank_id, diameter)

def set_tank_min_vol(name: str, tank_id: str, min_vol: float) -> ChangeSet:
    return api.set_tank_min_vol(name, tank_id, min_vol)

def set_tank_vol_curve(name: str, tank_id: str, vol_curve: str) -> ChangeSet:
    return api.set_tank_vol_curve(name, tank_id, vol_curve)

def set_tank_overflow(name: str, tank_id: str, overflow: str) -> ChangeSet:
    return api.set_tank_overflow(name, tank_id, overflow)

def set_tank_coord(name: str, tank_id: str, x: float, y: float) -> ChangeSet:
    return api.set_tank_coord(name, tank_id, x, y)


############################################################
# pipe 4.[PIPES]
############################################################

def add_pipe(name: str, pipe_id: str, node1: str, node2: str, length: float = 0, diameter: float = 0, roughness: float = 0, minor_loss: float = 0, status: str = PIPE_STATUS_OPEN) -> ChangeSet:
    return api.add_pipe(name, pipe_id, node1, node2, length, diameter, roughness, minor_loss, status)

def delete_pipe(name: str, pipe_id: str) -> ChangeSet:
    return api.delete_pipe(name, pipe_id)

def get_pipe_node1(name: str, pipe_id: str) -> str | None:
    return api.get_pipe_node1(name, pipe_id)

def get_pipe_node2(name: str, pipe_id: str) -> str | None:
    return api.get_pipe_node2(name, pipe_id)

def get_pipe_length(name: str, pipe_id: str) -> float | None:
    return api.get_pipe_length(name, pipe_id)

def get_pipe_diameter(name: str, pipe_id: str) -> float | None:
    return api.get_pipe_diameter(name, pipe_id)

def get_pipe_roughness(name: str, pipe_id: str) -> float | None:
    return api.get_pipe_roughness(name, pipe_id)

def get_pipe_minor_loss(name: str, pipe_id: str) -> float | None:
    return api.get_pipe_minor_loss(name, pipe_id)

def get_pipe_status(name: str, pipe_id: str) -> str | None:
    return api.get_pipe_status(name, pipe_id)

def set_pipe_node1(name: str, pipe_id: str, node1: str) -> ChangeSet:
    return api.set_pipe_node1(name, pipe_id, node1)

def set_pipe_node2(name: str, pipe_id: str, node2: str) -> ChangeSet:
    return api.set_pipe_node2(name, pipe_id, node2)

def set_pipe_length(name: str, pipe_id: str, length: float) -> ChangeSet:
    return api.set_pipe_length(name, pipe_id, length)

def set_pipe_diameter(name: str, pipe_id: str, diameter: float) -> ChangeSet:
    return api.set_pipe_diameter(name, pipe_id, diameter)

def set_pipe_roughness(name: str, pipe_id: str, roughness: float) -> ChangeSet:
    return api.set_pipe_roughness(name, pipe_id, roughness)

def set_pipe_minor_loss(name: str, pipe_id: str, minor_loss: float) -> ChangeSet:
    return api.set_pipe_minor_loss(name, pipe_id, minor_loss)

def set_pipe_status(name: str, pipe_id: str, status: float) -> ChangeSet:
    return api.set_pipe_status(name, pipe_id, status)


############################################################
# pump 4.[PUMPS]
############################################################

def add_pump(name: str, pump_id: str, node1: str, node2: str) -> ChangeSet:
    return api.add_pump(name, pump_id, node1, node2)

def delete_pump(name: str, pump_id: str) -> ChangeSet:
    return api.delete_pump(name, pump_id)

def get_pump_node1(name: str, pump_id: str) -> str | None:
    return api.get_pump_node1(name, pump_id)

def get_pump_node2(name: str, pump_id: str) -> str | None:
    return api.get_pump_node2(name, pump_id)

def set_pump_node1(name: str, pump_id: str, node1: str) -> ChangeSet:
    return api.set_pump_node1(name, pump_id, node1)

def set_pump_node2(name: str, pump_id: str, node2: str) -> ChangeSet:
    return api.set_pump_node2(name, pump_id, node2)


############################################################
# valve 4.[VALVES]
############################################################

def add_valve(name: str, valve_id: str, node1: str, node2: str, diameter: float = 0, type: str = VALVES_TYPE_PRV, setting: float = 0, minor_loss: float = 0) -> ChangeSet:
    return api.add_valve(name, valve_id, node1, node2, diameter, type, setting, minor_loss)

def delete_valve(name: str, valve_id: str) -> ChangeSet:
    return api.delete_valve(name, valve_id)

def get_valve_node1(name: str, valve_id: str) -> str | None:
    return api.get_valve_node1(name, valve_id)

def get_valve_node2(name: str, valve_id: str) -> str | None:
    return api.get_valve_node1(name, valve_id)

def get_valve_diameter(name: str, valve_id: str) -> float | None:
    return api.get_valve_diameter(name, valve_id)

def get_valve_type(name: str, valve_id: str) -> str | None:
    return api.get_valve_type(name, valve_id)

def get_valve_setting(name: str, valve_id: str) -> float | None:
    return api.get_valve_setting(name, valve_id)

def get_valve_minor_loss(name: str, valve_id: str) -> float | None:
    return api.get_valve_minor_loss(name, valve_id)

def set_valve_node1(name: str, valve_id: str, node1: str) -> ChangeSet:
    return api.set_valve_node1(name, valve_id, node1)

def set_valve_node2(name: str, valve_id: str, node2: str) -> ChangeSet:
    return api.set_valve_node2(name, valve_id, node2)

def set_valve_diameter(name: str, valve_id: str, diameter: float) -> ChangeSet:
    return api.set_valve_diameter(name, valve_id, diameter)

def set_valve_type(name: str, valve_id: str, type: str) -> ChangeSet:
    return api.set_valve_type(name, valve_id, type)

def set_valve_setting(name: str, valve_id: str, setting: float) -> ChangeSet:
    return api.set_valve_setting(name, valve_id, setting)

def set_valve_minor_loss(name: str, valve_id: str, minor_loss: float) -> ChangeSet:
    return api.set_valve_minor_loss(name, valve_id, minor_loss)


############################################################
# coordinates 24.[COORDINATES]
############################################################

def get_node_coord(name: str, node_id: str) -> dict[str, float] | None:
    return api.get_node_coord(name, node_id)

def set_node_coord(name: str, node_id: str, x: float, y: float) -> ChangeSet:
    return api.set_node_coord(name, node_id, x, y)