# studio_wrapper.py

import enum
from typing import Any
import nanosurf.lib.spm.studio.wrapper as wrap

g_cmd_tree_hash = 'c2a63bf288b75e44404c9e8c91497e6a'
g_compiler_version = '2.0'

class RootTestTabel(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.test.tabel'


class RootTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.test'
        self.tabel = RootTestTabel(self._context)

    @property
    def num_f(self) -> float:
        return float(self._context.get('root.test.num_f'))

    @num_f.setter
    def num_f(self, new_val:float):
        self._context.set('root.test.num_f', float(new_val))

    @property
    def num_i(self) -> int:
        return int(self._context.get('root.test.num_i'))

    @num_i.setter
    def num_i(self, new_val:int):
        self._context.set('root.test.num_i', int(new_val))

    def func(self, *args) -> Any:
        return self._context.call('root.test.func', *args)

    @property
    def str(self) -> str:
        return str(self._context.get('root.test.str'))

    @str.setter
    def str(self, new_val:str):
        self._context.set('root.test.str', str(new_val))

    @property
    def bool(self) -> bool:
        return bool(self._context.get('root.test.bool'))

    @bool.setter
    def bool(self, new_val:bool):
        self._context.set('root.test.bool', bool(new_val))


class RootUtil(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.util'

    def make_property(self, *args) -> Any:
        return self._context.call('root.util.make_property', *args)

    def deep_copy(self, *args) -> Any:
        return self._context.call('root.util.deep_copy', *args)

    def list_table_tables(self, *args) -> Any:
        return self._context.call('root.util.list_table_tables', *args)

    def num_table_invert(self, *args) -> Any:
        return self._context.call('root.util.num_table_invert', *args)

    def table_append(self, *args) -> Any:
        return self._context.call('root.util.table_append', *args)

    def prequire(self, *args) -> Any:
        return self._context.call('root.util.prequire', *args)

    def to_string(self, *args) -> Any:
        return self._context.call('root.util.to_string', *args)

    def filter_string_array_begin(self, *args) -> Any:
        return self._context.call('root.util.filter_string_array_begin', *args)

    def list_table_vars(self, *args) -> Any:
        return self._context.call('root.util.list_table_vars', *args)

    def list_table_elements(self, *args) -> Any:
        return self._context.call('root.util.list_table_elements', *args)

    def to_snake_case(self, *args) -> Any:
        return self._context.call('root.util.to_snake_case', *args)

    def list_table_functions(self, *args) -> Any:
        return self._context.call('root.util.list_table_functions', *args)

    def list_table_all(self, *args) -> Any:
        return self._context.call('root.util.list_table_all', *args)

    def deep_compare(self, *args) -> Any:
        return self._context.call('root.util.deep_compare', *args)

    def array_concat(self, *args) -> Any:
        return self._context.call('root.util.array_concat', *args)


class RootSession(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.session'

    def select_main(self, *args) -> Any:
        return self._context.call('root.session.select_main', *args)

    def select(self, *args) -> Any:
        return self._context.call('root.session.select', *args)

    @property
    def name(self) -> str:
        return str(self._context.get('root.session.name'))

    @name.setter
    def name(self, new_val:str):
        self._context.set('root.session.name', str(new_val))

    def list(self, *args) -> Any:
        return self._context.call('root.session.list', *args)

    @property
    def current_connection(self) -> str:
        return str(self._context.get('root.session.current_connection'))

    @current_connection.setter
    def current_connection(self, new_val:str):
        self._context.set('root.session.current_connection', str(new_val))


class RootCoreConverter_channel_correction(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.converter_channel_correction'


class RootCoreCore_environment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_environment'


class RootCoreDirect_motor_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.direct_motor_control'


class RootCoreOscilloscope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.oscilloscope'


class RootCoreScan_head_calibration(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.scan_head_calibration'


class RootCoreAcquisition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.acquisition'

    def write_data(self, *args) -> Any:
        return self._context.call('root.core.acquisition.write_data', *args)

    def erase_lu_data_buffer(self, *args) -> Any:
        return self._context.call('root.core.acquisition.erase_lu_data_buffer', *args)

    def lu_data_buffer_timestamp(self, *args) -> Any:
        return self._context.call('root.core.acquisition.lu_data_buffer_timestamp', *args)

    def lu_data_buffer_channel_count(self, *args) -> Any:
        return self._context.call('root.core.acquisition.lu_data_buffer_channel_count', *args)

    def lu_data_buffer_channel_data(self, *args) -> Any:
        return self._context.call('root.core.acquisition.lu_data_buffer_channel_data', *args)

    def reserve_lu_data_buffer(self, *args) -> Any:
        return self._context.call('root.core.acquisition.reserve_lu_data_buffer', *args)

    def lu_data_buffer_state(self, *args) -> Any:
        return self._context.call('root.core.acquisition.lu_data_buffer_state', *args)

    def trim_sampler_buffer(self, *args) -> Any:
        return self._context.call('root.core.acquisition.trim_sampler_buffer', *args)

    def synchronize_lu_data_buffer(self, *args) -> Any:
        return self._context.call('root.core.acquisition.synchronize_lu_data_buffer', *args)


class RootCoreSignal_store(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.signal_store'

    def get_signal_calibration_min_max(self, *args) -> Any:
        return self._context.call('root.core.signal_store.get_signal_calibration_min_max', *args)


class RootCoreImaging(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.imaging'


class RootCoreThermal_tuneSignalNew_average(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.new_average'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_average.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_average.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_average.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_average.connect_extended', *args)


class RootCoreThermal_tuneSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.procedure_info.connect_extended', *args)


class RootCoreThermal_tuneSignalNew_frequency_list(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.new_frequency_list'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_frequency_list.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_frequency_list.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_frequency_list.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_frequency_list.connect_extended', *args)


class RootCoreThermal_tuneSignalProgress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.progress'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.progress.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.progress.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.progress.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.progress.connect_extended', *args)


class RootCoreThermal_tuneSignalData_invalidated(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.data_invalidated'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.data_invalidated.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.data_invalidated.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.data_invalidated.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.data_invalidated.connect_extended', *args)


class RootCoreThermal_tuneSignalNew_fit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.new_fit'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_fit.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_fit.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_fit.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.new_fit.connect_extended', *args)


class RootCoreThermal_tuneSignalEnded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.ended'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.ended.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.ended.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.ended.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.ended.connect_extended', *args)


class RootCoreThermal_tuneSignalStarted(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal.started'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.signal.started.connect_extended', *args)


class RootCoreThermal_tuneSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.signal'
        self.started = RootCoreThermal_tuneSignalStarted(self._context)
        self.ended = RootCoreThermal_tuneSignalEnded(self._context)
        self.new_fit = RootCoreThermal_tuneSignalNew_fit(self._context)
        self.data_invalidated = RootCoreThermal_tuneSignalData_invalidated(self._context)
        self.progress = RootCoreThermal_tuneSignalProgress(self._context)
        self.new_frequency_list = RootCoreThermal_tuneSignalNew_frequency_list(self._context)
        self.procedure_info = RootCoreThermal_tuneSignalProcedure_info(self._context)
        self.new_average = RootCoreThermal_tuneSignalNew_average(self._context)


class RootCoreThermal_tunePropertyMeasurement_environment(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Air = 0
        Liquid = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.measurement_environment'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreThermal_tunePropertyMeasurement_environment.ValueEnum(self._context.get('root.core.thermal_tune.property.measurement_environment.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.thermal_tune.property.measurement_environment.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.thermal_tune.property.measurement_environment.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.thermal_tune.property.measurement_environment.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.thermal_tune.property.measurement_environment.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.thermal_tune.property.measurement_environment.enum', list(new_val))


class RootCoreThermal_tunePropertyFit_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.fit_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.thermal_tune.property.fit_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.thermal_tune.property.fit_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.thermal_tune.property.fit_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.thermal_tune.property.fit_frequency_lower_bound.unit', str(new_val))


class RootCoreThermal_tunePropertyTemperature(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.temperature'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.thermal_tune.property.temperature.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.thermal_tune.property.temperature.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.thermal_tune.property.temperature.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.thermal_tune.property.temperature.unit', str(new_val))


class RootCoreThermal_tunePropertyIterations(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.iterations'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.thermal_tune.property.iterations.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.thermal_tune.property.iterations.value', int(new_val))


class RootCoreThermal_tunePropertyResolution(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.resolution'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.thermal_tune.property.resolution.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.thermal_tune.property.resolution.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.thermal_tune.property.resolution.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.thermal_tune.property.resolution.unit', str(new_val))


class RootCoreThermal_tunePropertyFit_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.fit_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.thermal_tune.property.fit_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.thermal_tune.property.fit_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.thermal_tune.property.fit_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.thermal_tune.property.fit_frequency_upper_bound.unit', str(new_val))


class RootCoreThermal_tunePropertyMax_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property.max_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.thermal_tune.property.max_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.thermal_tune.property.max_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.thermal_tune.property.max_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.thermal_tune.property.max_frequency.unit', str(new_val))


class RootCoreThermal_tuneProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune.property'
        self.max_frequency = RootCoreThermal_tunePropertyMax_frequency(self._context)
        self.fit_frequency_upper_bound = RootCoreThermal_tunePropertyFit_frequency_upper_bound(self._context)
        self.resolution = RootCoreThermal_tunePropertyResolution(self._context)
        self.iterations = RootCoreThermal_tunePropertyIterations(self._context)
        self.temperature = RootCoreThermal_tunePropertyTemperature(self._context)
        self.fit_frequency_lower_bound = RootCoreThermal_tunePropertyFit_frequency_lower_bound(self._context)
        self.measurement_environment = RootCoreThermal_tunePropertyMeasurement_environment(self._context)


class RootCoreThermal_tune(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.thermal_tune'
        self.property = RootCoreThermal_tuneProperty(self._context)
        self.signal = RootCoreThermal_tuneSignal(self._context)

    def start(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.start', *args)

    def calculate_cantilever_calibration(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.calculate_cantilever_calibration', *args)

    def set_thermal_tune_parameters(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.set_thermal_tune_parameters', *args)

    def add_raw_data_to_fft_average_buffer(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.add_raw_data_to_fft_average_buffer', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.abort', *args)

    def create_fit_from_fft_average_buffer(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.create_fit_from_fft_average_buffer', *args)

    def generate_frequency_list(self, *args) -> Any:
        return self._context.call('root.core.thermal_tune.generate_frequency_list', *args)


class RootCoreApproachSignalApproach_or_withdraw_done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.signal.approach_or_withdraw_done'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.approach.signal.approach_or_withdraw_done.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach.signal.approach_or_withdraw_done.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.approach.signal.approach_or_withdraw_done.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.approach.signal.approach_or_withdraw_done.connect_extended', *args)


class RootCoreApproachSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.signal'
        self.approach_or_withdraw_done = RootCoreApproachSignalApproach_or_withdraw_done(self._context)


class RootCoreApproachPropertyStep_by_step_slope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_by_step_slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.step_by_step_slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.step_by_step_slope.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.step_by_step_slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.step_by_step_slope.unit', str(new_val))


class RootCoreApproachPropertyStep_by_step_coarse_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_by_step_coarse_step_size_percentage'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.approach.property.step_by_step_coarse_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.approach.property.step_by_step_coarse_step_size_percentage.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.step_by_step_coarse_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.step_by_step_coarse_step_size_percentage.unit', str(new_val))


class RootCoreApproachPropertyStep_by_step_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_by_step_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.step_by_step_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.step_by_step_time.value', float(new_val))


class RootCoreApproachPropertyStep_by_step_fine_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_by_step_fine_step_size_percentage'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.approach.property.step_by_step_fine_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.approach.property.step_by_step_fine_step_size_percentage.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.step_by_step_fine_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.step_by_step_fine_step_size_percentage.unit', str(new_val))


class RootCoreApproachPropertyMotor_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Internal = 0
        External = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.motor_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreApproachPropertyMotor_source.ValueEnum(self._context.get('root.core.approach.property.motor_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.approach.property.motor_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.approach.property.motor_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.approach.property.motor_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.approach.property.motor_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.approach.property.motor_source.enum', list(new_val))


class RootCoreApproachPropertyApproach_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.approach_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.approach_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.approach_pos.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.approach_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.approach_pos.unit', str(new_val))


class RootCoreApproachPropertyStep_by_step_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Tip_Position_Ignored = 2
        Not_Controlled = 1
        Position_Controlled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_by_step_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreApproachPropertyStep_by_step_mode.ValueEnum(self._context.get('root.core.approach.property.step_by_step_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.approach.property.step_by_step_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.approach.property.step_by_step_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.approach.property.step_by_step_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.approach.property.step_by_step_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.approach.property.step_by_step_mode.enum', list(new_val))


class RootCoreApproachPropertyApproach_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.approach_steps'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.approach.property.approach_steps.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.approach.property.approach_steps.value', int(new_val))


class RootCoreApproachPropertyStep_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.step_period'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.step_period.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.step_period.value', float(new_val))


class RootCoreApproachPropertyWithdraw_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.withdraw_steps'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.approach.property.withdraw_steps.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.approach.property.withdraw_steps.value', int(new_val))


class RootCoreApproachPropertyApproach_result(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.approach_result'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> str:
        return str(self._context.get('root.core.approach.property.approach_result.value'))

    @value.setter
    def value(self, new_val:str):
        self._context.set('root.core.approach.property.approach_result.value', str(new_val))


class RootCoreApproachPropertyApproach_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Continuous = 0
        Step_by_Step = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.approach_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreApproachPropertyApproach_mode.ValueEnum(self._context.get('root.core.approach.property.approach_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.approach.property.approach_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.approach.property.approach_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.approach.property.approach_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.approach.property.approach_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.approach.property.approach_mode.enum', list(new_val))


class RootCoreApproachPropertyApproach_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.approach_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.approach_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.approach_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.approach_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.approach_speed.unit', str(new_val))


class RootCoreApproachPropertyDeflection_offset_voltage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property.deflection_offset_voltage'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach.property.deflection_offset_voltage.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach.property.deflection_offset_voltage.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach.property.deflection_offset_voltage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach.property.deflection_offset_voltage.unit', str(new_val))


class RootCoreApproachProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach.property'
        self.deflection_offset_voltage = RootCoreApproachPropertyDeflection_offset_voltage(self._context)
        self.approach_speed = RootCoreApproachPropertyApproach_speed(self._context)
        self.approach_mode = RootCoreApproachPropertyApproach_mode(self._context)
        self.approach_result = RootCoreApproachPropertyApproach_result(self._context)
        self.withdraw_steps = RootCoreApproachPropertyWithdraw_steps(self._context)
        self.step_period = RootCoreApproachPropertyStep_period(self._context)
        self.approach_steps = RootCoreApproachPropertyApproach_steps(self._context)
        self.step_by_step_mode = RootCoreApproachPropertyStep_by_step_mode(self._context)
        self.approach_pos = RootCoreApproachPropertyApproach_pos(self._context)
        self.motor_source = RootCoreApproachPropertyMotor_source(self._context)
        self.step_by_step_fine_step_size_percentage = RootCoreApproachPropertyStep_by_step_fine_step_size_percentage(self._context)
        self.step_by_step_time = RootCoreApproachPropertyStep_by_step_time(self._context)
        self.step_by_step_coarse_step_size_percentage = RootCoreApproachPropertyStep_by_step_coarse_step_size_percentage(self._context)
        self.step_by_step_slope = RootCoreApproachPropertyStep_by_step_slope(self._context)


class RootCoreApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach'
        self.property = RootCoreApproachProperty(self._context)
        self.signal = RootCoreApproachSignal(self._context)

    def withdraw(self, *args) -> Any:
        return self._context.call('root.core.approach.withdraw', *args)

    def approach(self, *args) -> Any:
        return self._context.call('root.core.approach.approach', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.core.approach.abort', *args)


class RootCoreOrtPropertyBaseline_window_begin(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_window_begin'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.baseline_window_begin.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.baseline_window_begin.value', float(new_val))


class RootCoreOrtPropertyBaseline_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.baseline_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.baseline_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.ort.property.baseline_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.ort.property.baseline_frequency.unit', str(new_val))


class RootCoreOrtPropertyBaseline_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.baseline_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.baseline_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.ort.property.baseline_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.ort.property.baseline_value.unit', str(new_val))


class RootCoreOrtPropertyBaseline_window_end(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_window_end'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.baseline_window_end.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.baseline_window_end.value', float(new_val))


class RootCoreOrtPropertyAdhesion_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.adhesion_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.adhesion_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.adhesion_position.value', float(new_val))


class RootCoreOrtPropertyAmplitude_reduction(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.amplitude_reduction'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.amplitude_reduction.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.amplitude_reduction.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.ort.property.amplitude_reduction.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.ort.property.amplitude_reduction.unit', str(new_val))


class RootCoreOrtPropertySamples_per_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.samples_per_period'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.ort.property.samples_per_period.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.ort.property.samples_per_period.value', int(new_val))


class RootCoreOrtPropertyAdhesion_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.adhesion_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.adhesion_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.adhesion_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.ort.property.adhesion_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.ort.property.adhesion_value.unit', str(new_val))


class RootCoreOrtPropertyExcitation_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.excitation_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.ort.property.excitation_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.ort.property.excitation_enabled.value', bool(new_val))


class RootCoreOrtPropertyFeedback_amplitude_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.feedback_amplitude_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.feedback_amplitude_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.feedback_amplitude_position.value', float(new_val))


class RootCoreOrtPropertyInput_select(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Fast_In_User = 2
        Fast_In_Deflection = 0
        Hi_Res_In_User1 = 3
        Hi_Res_In_Deflection = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.input_select'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreOrtPropertyInput_select.ValueEnum(self._context.get('root.core.ort.property.input_select.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.ort.property.input_select.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.ort.property.input_select.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.ort.property.input_select.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.ort.property.input_select.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.ort.property.input_select.enum', list(new_val))


class RootCoreOrtPropertyAverage_periods(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.average_periods'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.ort.property.average_periods.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.ort.property.average_periods.value', int(new_val))


class RootCoreOrtPropertyFree_wave_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.free_wave_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.free_wave_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.free_wave_delay.value', float(new_val))


class RootCoreOrtPropertyCantilever_samples_per_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.cantilever_samples_per_period'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.ort.property.cantilever_samples_per_period.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.ort.property.cantilever_samples_per_period.value', int(new_val))


class RootCoreOrtPropertyBaseline_controller_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_controller_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.ort.property.baseline_controller_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.ort.property.baseline_controller_enabled.value', bool(new_val))


class RootCoreOrtPropertyBaseline_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property.baseline_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.ort.property.baseline_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.ort.property.baseline_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.ort.property.baseline_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.ort.property.baseline_amplitude.unit', str(new_val))


class RootCoreOrtProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort.property'
        self.baseline_amplitude = RootCoreOrtPropertyBaseline_amplitude(self._context)
        self.baseline_controller_enabled = RootCoreOrtPropertyBaseline_controller_enabled(self._context)
        self.cantilever_samples_per_period = RootCoreOrtPropertyCantilever_samples_per_period(self._context)
        self.free_wave_delay = RootCoreOrtPropertyFree_wave_delay(self._context)
        self.average_periods = RootCoreOrtPropertyAverage_periods(self._context)
        self.input_select = RootCoreOrtPropertyInput_select(self._context)
        self.feedback_amplitude_position = RootCoreOrtPropertyFeedback_amplitude_position(self._context)
        self.excitation_enabled = RootCoreOrtPropertyExcitation_enabled(self._context)
        self.adhesion_value = RootCoreOrtPropertyAdhesion_value(self._context)
        self.samples_per_period = RootCoreOrtPropertySamples_per_period(self._context)
        self.amplitude_reduction = RootCoreOrtPropertyAmplitude_reduction(self._context)
        self.adhesion_position = RootCoreOrtPropertyAdhesion_position(self._context)
        self.baseline_window_end = RootCoreOrtPropertyBaseline_window_end(self._context)
        self.baseline_value = RootCoreOrtPropertyBaseline_value(self._context)
        self.baseline_frequency = RootCoreOrtPropertyBaseline_frequency(self._context)
        self.baseline_window_begin = RootCoreOrtPropertyBaseline_window_begin(self._context)


class RootCoreOrt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.ort'
        self.property = RootCoreOrtProperty(self._context)

    def select_input(self, *args) -> Any:
        return self._context.call('root.core.ort.select_input', *args)

    def apply_samples_values(self, *args) -> Any:
        return self._context.call('root.core.ort.apply_samples_values', *args)

    def apply_samples_per_period(self, *args) -> Any:
        return self._context.call('root.core.ort.apply_samples_per_period', *args)

    def update_free_wave(self, *args) -> Any:
        return self._context.call('root.core.ort.update_free_wave', *args)

    def is_averaging(self, *args) -> Any:
        return self._context.call('root.core.ort.is_averaging', *args)

    def excitation_amplitude(self, *args) -> Any:
        return self._context.call('root.core.ort.excitation_amplitude', *args)


class RootCoreCore_options(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_options'


class RootCoreComp_dc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.comp_dc'


class RootCoreSpectroscopyPropertyFeedback_active(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.feedback_active'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.spectroscopy.property.feedback_active.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.spectroscopy.property.feedback_active.value', bool(new_val))


class RootCoreSpectroscopyPropertyForward_pause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_pause_time.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_pause_time.unit', str(new_val))


class RootCoreSpectroscopyPropertySpec_end_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Keep_Last_Z_Position = 0
        Z_Controller_Active = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.spec_end_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertySpec_end_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.spec_end_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.spec_end_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.spec_end_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.spec_end_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.spec_end_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.spec_end_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyXy_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.xy_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.xy_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.xy_move_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.xy_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.xy_move_speed.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_modulation_stop_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_modulation_stop_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_modulation_stop_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_modulation_stop_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_modulation_stop_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_modulation_stop_value.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_pause_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Z_On = 1
        Z_Off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_pause_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyBackward_pause_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.backward_pause_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.backward_pause_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.backward_pause_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.backward_pause_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.backward_pause_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.backward_pause_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyBackward_pause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_pause_time.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_pause_time.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_modulation_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_modulation_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_modulation_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_modulation_time.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_modulation_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_modulation_time.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_pause_sampling_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_pause_sampling_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_pause_sampling_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_pause_sampling_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_pause_sampling_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_pause_sampling_rate.unit', str(new_val))


class RootCoreSpectroscopyPropertyModulation_relative_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.modulation_relative_value'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.spectroscopy.property.modulation_relative_value.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.spectroscopy.property.modulation_relative_value.value', bool(new_val))


class RootCoreSpectroscopyPropertyAuto_recalibrate_probe_interval(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.auto_recalibrate_probe_interval'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.auto_recalibrate_probe_interval.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.auto_recalibrate_probe_interval.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.auto_recalibrate_probe_interval.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.auto_recalibrate_probe_interval.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_pause_sampling_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_pause_sampling_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_pause_sampling_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_pause_sampling_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_pause_sampling_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_pause_sampling_rate.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_modulation_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Fixed_Length = 0
        Stop_by_Value = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_modulation_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyBackward_modulation_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.backward_modulation_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.backward_modulation_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.backward_modulation_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.backward_modulation_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.backward_modulation_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.backward_modulation_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyRepetition_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.repetition_count'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.repetition_count.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.repetition_count.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.repetition_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.repetition_count.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_datapoints'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.forward_datapoints.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.forward_datapoints.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_datapoints.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_move_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_move_speed.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_datapoints'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.backward_datapoints.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.backward_datapoints.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_datapoints.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_modulation_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_modulation_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_modulation_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_modulation_time.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_modulation_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_modulation_time.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_modulation_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Fixed_Length = 0
        Stop_by_Value = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_modulation_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyForward_modulation_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.forward_modulation_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.forward_modulation_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.forward_modulation_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.forward_modulation_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.forward_modulation_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.forward_modulation_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyBackward_modulation_stop_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Is_Less_Than = 0
        Is_Greater_Than = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_modulation_stop_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyBackward_modulation_stop_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.backward_modulation_stop_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.backward_modulation_stop_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.backward_modulation_stop_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.backward_modulation_stop_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.backward_modulation_stop_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.backward_modulation_stop_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyBackward_modulation_stop_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_modulation_stop_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_modulation_stop_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_modulation_stop_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_modulation_stop_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_modulation_stop_value.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_move_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_move_speed.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_sampling_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_sampling_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_sampling_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_sampling_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_sampling_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_sampling_rate.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_modulation_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_modulation_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.backward_modulation_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.backward_modulation_range.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_modulation_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_modulation_range.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_pause_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Z_On = 1
        Z_Off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_pause_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyForward_pause_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.forward_pause_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.forward_pause_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.forward_pause_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.forward_pause_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.forward_pause_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.forward_pause_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertyForward_sampling_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_sampling_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_sampling_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_sampling_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_sampling_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_sampling_rate.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_modulation_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_modulation_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.forward_modulation_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.forward_modulation_range.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_modulation_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_modulation_range.unit', str(new_val))


class RootCoreSpectroscopyPropertyModulation_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        External_Z = 2
        Tip_Voltage = 1
        Position_Z = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.modulation_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyModulation_output.ValueEnum(self._context.get('root.core.spectroscopy.property.modulation_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.modulation_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.modulation_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.modulation_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.modulation_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.modulation_output.enum', list(new_val))


class RootCoreSpectroscopyPropertyForward_pause_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_pause_datapoints'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.forward_pause_datapoints.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.forward_pause_datapoints.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.forward_pause_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.forward_pause_datapoints.unit', str(new_val))


class RootCoreSpectroscopyPropertyStart_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.start_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.start_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.start_offset.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.start_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.start_offset.unit', str(new_val))


class RootCoreSpectroscopyPropertyBackward_pause_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.backward_pause_datapoints'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.backward_pause_datapoints.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.backward_pause_datapoints.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.backward_pause_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.backward_pause_datapoints.unit', str(new_val))


class RootCoreSpectroscopyPropertyForward_modulation_stop_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Is_Less_Than = 0
        Is_Greater_Than = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.forward_modulation_stop_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreSpectroscopyPropertyForward_modulation_stop_mode.ValueEnum(self._context.get('root.core.spectroscopy.property.forward_modulation_stop_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.spectroscopy.property.forward_modulation_stop_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.forward_modulation_stop_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.forward_modulation_stop_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.spectroscopy.property.forward_modulation_stop_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.spectroscopy.property.forward_modulation_stop_mode.enum', list(new_val))


class RootCoreSpectroscopyPropertySample_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.sample_mask'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.spectroscopy.property.sample_mask.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.spectroscopy.property.sample_mask.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.sample_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.sample_mask.unit', str(new_val))


class RootCoreSpectroscopyPropertyStart_offste_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property.start_offste_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.spectroscopy.property.start_offste_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.spectroscopy.property.start_offste_move_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.spectroscopy.property.start_offste_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.spectroscopy.property.start_offste_move_speed.unit', str(new_val))


class RootCoreSpectroscopyProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.property'
        self.start_offste_move_speed = RootCoreSpectroscopyPropertyStart_offste_move_speed(self._context)
        self.sample_mask = RootCoreSpectroscopyPropertySample_mask(self._context)
        self.forward_modulation_stop_mode = RootCoreSpectroscopyPropertyForward_modulation_stop_mode(self._context)
        self.backward_pause_datapoints = RootCoreSpectroscopyPropertyBackward_pause_datapoints(self._context)
        self.start_offset = RootCoreSpectroscopyPropertyStart_offset(self._context)
        self.forward_pause_datapoints = RootCoreSpectroscopyPropertyForward_pause_datapoints(self._context)
        self.modulation_output = RootCoreSpectroscopyPropertyModulation_output(self._context)
        self.forward_modulation_range = RootCoreSpectroscopyPropertyForward_modulation_range(self._context)
        self.forward_sampling_rate = RootCoreSpectroscopyPropertyForward_sampling_rate(self._context)
        self.forward_pause_mode = RootCoreSpectroscopyPropertyForward_pause_mode(self._context)
        self.backward_modulation_range = RootCoreSpectroscopyPropertyBackward_modulation_range(self._context)
        self.backward_sampling_rate = RootCoreSpectroscopyPropertyBackward_sampling_rate(self._context)
        self.forward_move_speed = RootCoreSpectroscopyPropertyForward_move_speed(self._context)
        self.backward_modulation_stop_value = RootCoreSpectroscopyPropertyBackward_modulation_stop_value(self._context)
        self.backward_modulation_stop_mode = RootCoreSpectroscopyPropertyBackward_modulation_stop_mode(self._context)
        self.forward_modulation_mode = RootCoreSpectroscopyPropertyForward_modulation_mode(self._context)
        self.forward_modulation_time = RootCoreSpectroscopyPropertyForward_modulation_time(self._context)
        self.backward_datapoints = RootCoreSpectroscopyPropertyBackward_datapoints(self._context)
        self.backward_move_speed = RootCoreSpectroscopyPropertyBackward_move_speed(self._context)
        self.forward_datapoints = RootCoreSpectroscopyPropertyForward_datapoints(self._context)
        self.repetition_count = RootCoreSpectroscopyPropertyRepetition_count(self._context)
        self.backward_modulation_mode = RootCoreSpectroscopyPropertyBackward_modulation_mode(self._context)
        self.forward_pause_sampling_rate = RootCoreSpectroscopyPropertyForward_pause_sampling_rate(self._context)
        self.auto_recalibrate_probe_interval = RootCoreSpectroscopyPropertyAuto_recalibrate_probe_interval(self._context)
        self.modulation_relative_value = RootCoreSpectroscopyPropertyModulation_relative_value(self._context)
        self.backward_pause_sampling_rate = RootCoreSpectroscopyPropertyBackward_pause_sampling_rate(self._context)
        self.backward_modulation_time = RootCoreSpectroscopyPropertyBackward_modulation_time(self._context)
        self.backward_pause_time = RootCoreSpectroscopyPropertyBackward_pause_time(self._context)
        self.backward_pause_mode = RootCoreSpectroscopyPropertyBackward_pause_mode(self._context)
        self.forward_modulation_stop_value = RootCoreSpectroscopyPropertyForward_modulation_stop_value(self._context)
        self.xy_move_speed = RootCoreSpectroscopyPropertyXy_move_speed(self._context)
        self.spec_end_mode = RootCoreSpectroscopyPropertySpec_end_mode(self._context)
        self.forward_pause_time = RootCoreSpectroscopyPropertyForward_pause_time(self._context)
        self.feedback_active = RootCoreSpectroscopyPropertyFeedback_active(self._context)


class RootCoreSpectroscopySignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy.signal'


class RootCoreSpectroscopy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.spectroscopy'
        self.signal = RootCoreSpectroscopySignal(self._context)
        self.property = RootCoreSpectroscopyProperty(self._context)

    def start(self, *args) -> Any:
        return self._context.call('root.core.spectroscopy.start', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.core.spectroscopy.abort', *args)


class RootCoreZ_controllerPropertyActual_feedback_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.actual_feedback_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.z_controller.property.actual_feedback_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.z_controller.property.actual_feedback_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.z_controller.property.actual_feedback_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.z_controller.property.actual_feedback_value.unit', str(new_val))


class RootCoreZ_controllerPropertyD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.d_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.z_controller.property.d_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.z_controller.property.d_gain.value', int(new_val))


class RootCoreZ_controllerPropertySetpoint(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.setpoint'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.z_controller.property.setpoint.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.z_controller.property.setpoint.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.z_controller.property.setpoint.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.z_controller.property.setpoint.unit', str(new_val))


class RootCoreZ_controllerPropertyI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.i_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.z_controller.property.i_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.z_controller.property.i_gain.value', int(new_val))


class RootCoreZ_controllerPropertyMin_z_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.min_z_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.z_controller.property.min_z_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.z_controller.property.min_z_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.z_controller.property.min_z_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.z_controller.property.min_z_value.unit', str(new_val))


class RootCoreZ_controllerPropertyP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.p_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.z_controller.property.p_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.z_controller.property.p_gain.value', int(new_val))


class RootCoreZ_controllerPropertyActual_tip_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.actual_tip_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.z_controller.property.actual_tip_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.z_controller.property.actual_tip_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.z_controller.property.actual_tip_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.z_controller.property.actual_tip_position.unit', str(new_val))


class RootCoreZ_controllerPropertyIdle_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Keep_Last_Z_Position = 2
        Retract_Tip = 1
        Absolute_Z_Position = 3
        Enable_Z_Controller = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.idle_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreZ_controllerPropertyIdle_mode.ValueEnum(self._context.get('root.core.z_controller.property.idle_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.z_controller.property.idle_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.z_controller.property.idle_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.z_controller.property.idle_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.z_controller.property.idle_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.z_controller.property.idle_mode.enum', list(new_val))


class RootCoreZ_controllerPropertyAbsolute_idle_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.absolute_idle_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.z_controller.property.absolute_idle_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.z_controller.property.absolute_idle_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.z_controller.property.absolute_idle_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.z_controller.property.absolute_idle_position.unit', str(new_val))


class RootCoreZ_controllerPropertyFeedback_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        negative = 1
        invalid = 2
        positive = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.feedback_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreZ_controllerPropertyFeedback_polarity.ValueEnum(self._context.get('root.core.z_controller.property.feedback_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.z_controller.property.feedback_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.z_controller.property.feedback_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.z_controller.property.feedback_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.z_controller.property.feedback_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.z_controller.property.feedback_polarity.enum', list(new_val))


class RootCoreZ_controllerPropertyFeedback(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Deflection = 0
        Dynamic_Mode_Amplitude_Reduction = 2
        WaveMode_Amplitude_Reduction = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.feedback'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreZ_controllerPropertyFeedback.ValueEnum(self._context.get('root.core.z_controller.property.feedback.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.z_controller.property.feedback.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.z_controller.property.feedback.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.z_controller.property.feedback.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.z_controller.property.feedback.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.z_controller.property.feedback.enum', list(new_val))


class RootCoreZ_controllerPropertyBase_work_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Control_Z_by_Z_Sensor = 0
        Control_Z_by_Measurement_Mode = 2
        Drive_Z = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property.base_work_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreZ_controllerPropertyBase_work_mode.ValueEnum(self._context.get('root.core.z_controller.property.base_work_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.z_controller.property.base_work_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.z_controller.property.base_work_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.z_controller.property.base_work_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.z_controller.property.base_work_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.z_controller.property.base_work_mode.enum', list(new_val))


class RootCoreZ_controllerProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.property'
        self.base_work_mode = RootCoreZ_controllerPropertyBase_work_mode(self._context)
        self.feedback = RootCoreZ_controllerPropertyFeedback(self._context)
        self.feedback_polarity = RootCoreZ_controllerPropertyFeedback_polarity(self._context)
        self.absolute_idle_position = RootCoreZ_controllerPropertyAbsolute_idle_position(self._context)
        self.idle_mode = RootCoreZ_controllerPropertyIdle_mode(self._context)
        self.actual_tip_position = RootCoreZ_controllerPropertyActual_tip_position(self._context)
        self.p_gain = RootCoreZ_controllerPropertyP_gain(self._context)
        self.min_z_value = RootCoreZ_controllerPropertyMin_z_value(self._context)
        self.i_gain = RootCoreZ_controllerPropertyI_gain(self._context)
        self.setpoint = RootCoreZ_controllerPropertySetpoint(self._context)
        self.d_gain = RootCoreZ_controllerPropertyD_gain(self._context)
        self.actual_feedback_value = RootCoreZ_controllerPropertyActual_feedback_value(self._context)


class RootCoreZ_controllerSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller.signal'


class RootCoreZ_controller(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.z_controller'
        self.signal = RootCoreZ_controllerSignal(self._context)
        self.property = RootCoreZ_controllerProperty(self._context)

    def tip_position_lower_limit(self, *args) -> Any:
        return self._context.call('root.core.z_controller.tip_position_lower_limit', *args)

    def retract_tip(self, *args) -> Any:
        return self._context.call('root.core.z_controller.retract_tip', *args)

    def setpoint_limits_from_calibration(self, *args) -> Any:
        return self._context.call('root.core.z_controller.setpoint_limits_from_calibration', *args)

    def setpoint_upper_limit(self, *args) -> Any:
        return self._context.call('root.core.z_controller.setpoint_upper_limit', *args)


class RootCoreLaser_align_drive_implSignalAuto_align_pte_aligned(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.auto_align_pte_aligned'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_pte_aligned.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_pte_aligned.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_pte_aligned.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_pte_aligned.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalAuto_align_search_step_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.auto_align_search_step_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_search_step_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_search_step_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_search_step_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_search_step_finished.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalCenter_detector_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.center_detector_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.center_detector_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.center_detector_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.center_detector_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.center_detector_finished.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalMotor_move_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.motor_move_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_started.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalMotor_move_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.motor_move_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.motor_move_finished.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.procedure_info.connect_extended', *args)


class RootCoreLaser_align_drive_implSignalAuto_align_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal.auto_align_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.signal.auto_align_finished.connect_extended', *args)


class RootCoreLaser_align_drive_implSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.signal'
        self.auto_align_finished = RootCoreLaser_align_drive_implSignalAuto_align_finished(self._context)
        self.procedure_info = RootCoreLaser_align_drive_implSignalProcedure_info(self._context)
        self.motor_move_finished = RootCoreLaser_align_drive_implSignalMotor_move_finished(self._context)
        self.motor_move_started = RootCoreLaser_align_drive_implSignalMotor_move_started(self._context)
        self.center_detector_finished = RootCoreLaser_align_drive_implSignalCenter_detector_finished(self._context)
        self.auto_align_search_step_finished = RootCoreLaser_align_drive_implSignalAuto_align_search_step_finished(self._context)
        self.auto_align_pte_aligned = RootCoreLaser_align_drive_implSignalAuto_align_pte_aligned(self._context)


class RootCoreLaser_align_drive_implPropertyLaser_clean_drive_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_clean_drive_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.laser_clean_drive_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.laser_clean_drive_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.laser_clean_drive_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.laser_clean_drive_amplitude.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_readout_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_readout_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_readout_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_readout_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_readout_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_readout_y_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyScan_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.scan_mode'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.laser_align_drive_impl.property.scan_mode.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.laser_align_drive_impl.property.scan_mode.value', bool(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_focus(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_speed_max_laser_focus'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_laser_focus.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_laser_focus.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_laser_focus.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_laser_focus.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_speed_laser_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_speed_laser_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_laser_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_laser_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_laser_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_laser_motors.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyLaser_clean_drive_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_clean_drive_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.laser_align_drive_impl.property.laser_clean_drive_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.laser_align_drive_impl.property.laser_clean_drive_enabled.value', bool(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_speed_max_beam_shifter(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_speed_max_beam_shifter'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_beam_shifter.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_beam_shifter.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_beam_shifter.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_beam_shifter.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_beam_shifter_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_beam_shifter_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_beam_shifter_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_beam_shifter_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_beam_shifter_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_beam_shifter_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertySensor_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Low = 1
        Fail = 4
        Undefined = 0
        Ok = 2
        High = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.sensor_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreLaser_align_drive_implPropertySensor_status.ValueEnum(self._context.get('root.core.laser_align_drive_impl.property.sensor_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.laser_align_drive_impl.property.sensor_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.laser_align_drive_impl.property.sensor_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.laser_align_drive_impl.property.sensor_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.laser_align_drive_impl.property.sensor_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.laser_align_drive_impl.property.sensor_status.enum', list(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_photodetector_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_photodetector_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_photodetector_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_photodetector_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_photodetector_y_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_clean_drive_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_x_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyLaser_readout_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_readout_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.core.laser_align_drive_impl.property.laser_readout_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.core.laser_align_drive_impl.property.laser_readout_enabled.value', bool(new_val))


class RootCoreLaser_align_drive_implPropertyLaser_readout_power(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_readout_power'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.laser_readout_power.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.laser_readout_power.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.laser_readout_power.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.laser_readout_power.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_photodetector_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_photodetector_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_photodetector_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_photodetector_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_photodetector_x_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyLaser_clean_drive_power(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_clean_drive_power'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.laser_clean_drive_power.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.laser_clean_drive_power.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.laser_clean_drive_power.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.laser_clean_drive_power.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_speed_max_laser_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_laser_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_laser_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_speed_max_laser_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_speed_max_laser_motors.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_clean_drive_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_clean_drive_y_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyDeflection_offset_calibration_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Calibration_Error = 1
        No_Error = 0
        Sensor_Signal_Failed = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.deflection_offset_calibration_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreLaser_align_drive_implPropertyDeflection_offset_calibration_status.ValueEnum(self._context.get('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_offset_calibration_status.enum', list(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_focus_z_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_focus_z_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_focus_z_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_focus_z_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_focus_z_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_focus_z_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyLaser_spot_intensity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.laser_spot_intensity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.laser_spot_intensity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.laser_spot_intensity.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.laser_spot_intensity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.laser_spot_intensity.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyMotor_laser_readout_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.motor_laser_readout_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_readout_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_readout_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.motor_laser_readout_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.motor_laser_readout_x_position.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyDeflection_lateral(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.deflection_lateral'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.deflection_lateral.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_lateral.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.deflection_lateral.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_lateral.unit', str(new_val))


class RootCoreLaser_align_drive_implPropertyDeflection_normal(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property.deflection_normal'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.laser_align_drive_impl.property.deflection_normal.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_normal.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.laser_align_drive_impl.property.deflection_normal.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.laser_align_drive_impl.property.deflection_normal.unit', str(new_val))


class RootCoreLaser_align_drive_implProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl.property'
        self.deflection_normal = RootCoreLaser_align_drive_implPropertyDeflection_normal(self._context)
        self.deflection_lateral = RootCoreLaser_align_drive_implPropertyDeflection_lateral(self._context)
        self.motor_laser_readout_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_readout_x_position(self._context)
        self.laser_spot_intensity = RootCoreLaser_align_drive_implPropertyLaser_spot_intensity(self._context)
        self.motor_laser_focus_z_position = RootCoreLaser_align_drive_implPropertyMotor_laser_focus_z_position(self._context)
        self.deflection_offset_calibration_status = RootCoreLaser_align_drive_implPropertyDeflection_offset_calibration_status(self._context)
        self.motor_laser_clean_drive_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_y_position(self._context)
        self.motor_speed_max_laser_motors = RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_motors(self._context)
        self.laser_clean_drive_power = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_power(self._context)
        self.motor_laser_photodetector_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_x_position(self._context)
        self.laser_readout_power = RootCoreLaser_align_drive_implPropertyLaser_readout_power(self._context)
        self.laser_readout_enabled = RootCoreLaser_align_drive_implPropertyLaser_readout_enabled(self._context)
        self.motor_laser_clean_drive_x_position = RootCoreLaser_align_drive_implPropertyMotor_laser_clean_drive_x_position(self._context)
        self.motor_laser_photodetector_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_photodetector_y_position(self._context)
        self.sensor_status = RootCoreLaser_align_drive_implPropertySensor_status(self._context)
        self.motor_beam_shifter_position = RootCoreLaser_align_drive_implPropertyMotor_beam_shifter_position(self._context)
        self.motor_speed_max_beam_shifter = RootCoreLaser_align_drive_implPropertyMotor_speed_max_beam_shifter(self._context)
        self.laser_clean_drive_enabled = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_enabled(self._context)
        self.motor_speed_laser_motors = RootCoreLaser_align_drive_implPropertyMotor_speed_laser_motors(self._context)
        self.motor_speed_max_laser_focus = RootCoreLaser_align_drive_implPropertyMotor_speed_max_laser_focus(self._context)
        self.scan_mode = RootCoreLaser_align_drive_implPropertyScan_mode(self._context)
        self.motor_laser_readout_y_position = RootCoreLaser_align_drive_implPropertyMotor_laser_readout_y_position(self._context)
        self.laser_clean_drive_amplitude = RootCoreLaser_align_drive_implPropertyLaser_clean_drive_amplitude(self._context)


class RootCoreLaser_align_drive_impl(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.laser_align_drive_impl'
        self.property = RootCoreLaser_align_drive_implProperty(self._context)
        self.signal = RootCoreLaser_align_drive_implSignal(self._context)

    def stop_updating_detector_status(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.stop_updating_detector_status', *args)

    def start_move_to_optical_center(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_move_to_optical_center', *args)

    def auto_align(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.auto_align', *args)

    def move_motors_by_step(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.move_motors_by_step', *args)

    def zero_position(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.zero_position', *args)

    def stop_motors(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.stop_motors', *args)

    def start_updating_detector_status(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_updating_detector_status', *args)

    def start_moving_motors(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_moving_motors', *args)

    def center_detector(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.center_detector', *args)

    def abort_auto_align(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.abort_auto_align', *args)

    def start_search_algorithm(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_search_algorithm', *args)

    def reference_motor(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.reference_motor', *args)

    def start_optimizing(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.start_optimizing', *args)

    def abort_center_detector(self, *args) -> Any:
        return self._context.call('root.core.laser_align_drive_impl.abort_center_detector', *args)


class RootCoreApproach_motors_driveSignalMotor_move_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.signal.motor_move_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_finished.connect_extended', *args)


class RootCoreApproach_motors_driveSignalMotor_move_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.signal.motor_move_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.signal.motor_move_started.connect_extended', *args)


class RootCoreApproach_motors_driveSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.signal'
        self.motor_move_started = RootCoreApproach_motors_driveSignalMotor_move_started(self._context)
        self.motor_move_finished = RootCoreApproach_motors_driveSignalMotor_move_finished(self._context)


class RootCoreApproach_motors_drivePropertyMotor_speed_advance_retract(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_speed_advance_retract'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_speed_advance_retract.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_speed_advance_retract.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_speed_advance_retract.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_speed_advance_retract.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyMotor_speed_approach_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_speed_approach_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_speed_approach_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_speed_approach_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_speed_approach_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_speed_approach_motors.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyMotor_right_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_right_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_right_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_right_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_right_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_right_position.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyRelative_tip_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.relative_tip_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.relative_tip_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.relative_tip_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.relative_tip_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.relative_tip_position.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyMotor_front_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_front_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_front_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_front_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_front_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_front_position.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyMotor_left_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_left_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_left_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_left_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_left_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_left_position.unit', str(new_val))


class RootCoreApproach_motors_drivePropertyMotor_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property.motor_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.approach_motors_drive.property.motor_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.approach_motors_drive.property.motor_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.approach_motors_drive.property.motor_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.approach_motors_drive.property.motor_speed.unit', str(new_val))


class RootCoreApproach_motors_driveProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive.property'
        self.motor_speed = RootCoreApproach_motors_drivePropertyMotor_speed(self._context)
        self.motor_left_position = RootCoreApproach_motors_drivePropertyMotor_left_position(self._context)
        self.motor_front_position = RootCoreApproach_motors_drivePropertyMotor_front_position(self._context)
        self.relative_tip_position = RootCoreApproach_motors_drivePropertyRelative_tip_position(self._context)
        self.motor_right_position = RootCoreApproach_motors_drivePropertyMotor_right_position(self._context)
        self.motor_speed_approach_motors = RootCoreApproach_motors_drivePropertyMotor_speed_approach_motors(self._context)
        self.motor_speed_advance_retract = RootCoreApproach_motors_drivePropertyMotor_speed_advance_retract(self._context)


class RootCoreApproach_motors_drive(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.approach_motors_drive'
        self.property = RootCoreApproach_motors_driveProperty(self._context)
        self.signal = RootCoreApproach_motors_driveSignal(self._context)

    def stop_motors(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.stop_motors', *args)

    def start_moving_motors(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.start_moving_motors', *args)

    def move_motors_by_step(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.move_motors_by_step', *args)

    def zero_position(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.zero_position', *args)

    def reference_motors(self, *args) -> Any:
        return self._context.call('root.core.approach_motors_drive.reference_motors', *args)


class RootCoreCore_cantileverPropertySelected_cantilever_spring_constant(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_cantilever.property.selected_cantilever_spring_constant'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.core_cantilever.property.selected_cantilever_spring_constant.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.core_cantilever.property.selected_cantilever_spring_constant.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.core_cantilever.property.selected_cantilever_spring_constant.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.core_cantilever.property.selected_cantilever_spring_constant.unit', str(new_val))


class RootCoreCore_cantileverPropertySelected_cantilever_deflection_sensitivity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_cantilever.property.selected_cantilever_deflection_sensitivity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.core_cantilever.property.selected_cantilever_deflection_sensitivity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.core_cantilever.property.selected_cantilever_deflection_sensitivity.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.core_cantilever.property.selected_cantilever_deflection_sensitivity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.core_cantilever.property.selected_cantilever_deflection_sensitivity.unit', str(new_val))


class RootCoreCore_cantileverProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_cantilever.property'
        self.selected_cantilever_deflection_sensitivity = RootCoreCore_cantileverPropertySelected_cantilever_deflection_sensitivity(self._context)
        self.selected_cantilever_spring_constant = RootCoreCore_cantileverPropertySelected_cantilever_spring_constant(self._context)


class RootCoreCore_cantilever(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_cantilever'
        self.property = RootCoreCore_cantileverProperty(self._context)

    def select_cantilever(self, *args) -> Any:
        return self._context.call('root.core.core_cantilever.select_cantilever', *args)

    def selected_cantilever(self, *args) -> Any:
        return self._context.call('root.core.core_cantilever.selected_cantilever', *args)

    def apply(self, *args) -> Any:
        return self._context.call('root.core.core_cantilever.apply', *args)


class RootCoreFrequency_sweepSignalNew_fit_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.new_fit_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_fit_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_fit_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_fit_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_fit_data.connect_extended', *args)


class RootCoreFrequency_sweepSignalNew_sweep_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.new_sweep_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_sweep_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_sweep_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_sweep_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.new_sweep_data.connect_extended', *args)


class RootCoreFrequency_sweepSignalProcess_sweep_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.process_sweep_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.process_sweep_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.process_sweep_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.process_sweep_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.process_sweep_data.connect_extended', *args)


class RootCoreFrequency_sweepSignalSho_fit_failed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.sho_fit_failed'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sho_fit_failed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sho_fit_failed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sho_fit_failed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sho_fit_failed.connect_extended', *args)


class RootCoreFrequency_sweepSignalData_invalidated(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.data_invalidated'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.data_invalidated.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.data_invalidated.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.data_invalidated.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.data_invalidated.connect_extended', *args)


class RootCoreFrequency_sweepSignalSweep_progress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.sweep_progress'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_progress.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_progress.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_progress.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_progress.connect_extended', *args)


class RootCoreFrequency_sweepSignalSweep_ended(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal.sweep_ended'

    def empty(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_ended.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_ended.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_ended.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.signal.sweep_ended.connect_extended', *args)


class RootCoreFrequency_sweepSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.signal'
        self.sweep_ended = RootCoreFrequency_sweepSignalSweep_ended(self._context)
        self.sweep_progress = RootCoreFrequency_sweepSignalSweep_progress(self._context)
        self.data_invalidated = RootCoreFrequency_sweepSignalData_invalidated(self._context)
        self.sho_fit_failed = RootCoreFrequency_sweepSignalSho_fit_failed(self._context)
        self.process_sweep_data = RootCoreFrequency_sweepSignalProcess_sweep_data(self._context)
        self.new_sweep_data = RootCoreFrequency_sweepSignalNew_sweep_data(self._context)
        self.new_fit_data = RootCoreFrequency_sweepSignalNew_fit_data(self._context)


class RootCoreFrequency_sweepPropertyFrequency_selection_criteria(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Below_Peak = 0
        Above_Peak = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.frequency_selection_criteria'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreFrequency_sweepPropertyFrequency_selection_criteria.ValueEnum(self._context.get('root.core.frequency_sweep.property.frequency_selection_criteria.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.frequency_sweep.property.frequency_selection_criteria.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.frequency_sweep.property.frequency_selection_criteria.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.frequency_sweep.property.frequency_selection_criteria.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.frequency_sweep.property.frequency_selection_criteria.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.frequency_sweep.property.frequency_selection_criteria.enum', list(new_val))


class RootCoreFrequency_sweepPropertyNew_spring_constant(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.new_spring_constant'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.new_spring_constant.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.new_spring_constant.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.new_spring_constant.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.new_spring_constant.unit', str(new_val))


class RootCoreFrequency_sweepPropertyAmplitude_unit(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Volts_V_ = 1
        Meters_m_ = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.amplitude_unit'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreFrequency_sweepPropertyAmplitude_unit.ValueEnum(self._context.get('root.core.frequency_sweep.property.amplitude_unit.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.frequency_sweep.property.amplitude_unit.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.frequency_sweep.property.amplitude_unit.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.frequency_sweep.property.amplitude_unit.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.frequency_sweep.property.amplitude_unit.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.frequency_sweep.property.amplitude_unit.enum', list(new_val))


class RootCoreFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        num_360_Hz = 5
        num_12_kHz = 10
        num_180_Hz = 4
        num_230_kHz = 14
        num_500_kHz = 15
        num_1500_Hz = 7
        num_750_Hz = 6
        num_100_kHz = 13
        num_3_kHz = 8
        num_23_kHz = 11
        num_45_kHz = 12
        num_6_kHz = 9
        num_90_Hz = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.analyzer_demodulator_bandwidth'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreFrequency_sweepPropertyAnalyzer_demodulator_bandwidth.ValueEnum(self._context.get('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.frequency_sweep.property.analyzer_demodulator_bandwidth.enum', list(new_val))


class RootCoreFrequency_sweepPropertySweep_data_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.sweep_data_points'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.core.frequency_sweep.property.sweep_data_points.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.core.frequency_sweep.property.sweep_data_points.value', int(new_val))


class RootCoreFrequency_sweepPropertyAmplitude_reduction(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.amplitude_reduction'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.amplitude_reduction.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.amplitude_reduction.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.amplitude_reduction.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.amplitude_reduction.unit', str(new_val))


class RootCoreFrequency_sweepPropertyNew_excitation_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.new_excitation_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.new_excitation_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.new_excitation_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.new_excitation_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.new_excitation_frequency.unit', str(new_val))


class RootCoreFrequency_sweepPropertySweep_free_vibration_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.sweep_free_vibration_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.sweep_free_vibration_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.sweep_free_vibration_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.sweep_free_vibration_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.sweep_free_vibration_amplitude.unit', str(new_val))


class RootCoreFrequency_sweepPropertySweep_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.sweep_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.sweep_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.sweep_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.sweep_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.sweep_frequency_lower_bound.unit', str(new_val))


class RootCoreFrequency_sweepPropertyFit_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.fit_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.fit_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.fit_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.fit_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.fit_frequency_lower_bound.unit', str(new_val))


class RootCoreFrequency_sweepPropertyTemperature(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.temperature'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.temperature.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.temperature.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.temperature.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.temperature.unit', str(new_val))


class RootCoreFrequency_sweepPropertySweep_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.sweep_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.sweep_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.sweep_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.sweep_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.sweep_frequency_upper_bound.unit', str(new_val))


class RootCoreFrequency_sweepPropertySweep_excitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.sweep_excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.sweep_excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.sweep_excitation_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.sweep_excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.sweep_excitation_amplitude.unit', str(new_val))


class RootCoreFrequency_sweepPropertyFit_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.fit_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.core.frequency_sweep.property.fit_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.core.frequency_sweep.property.fit_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.core.frequency_sweep.property.fit_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.core.frequency_sweep.property.fit_frequency_upper_bound.unit', str(new_val))


class RootCoreFrequency_sweepPropertyMeasurement_environment(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Air = 0
        Liquid = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property.measurement_environment'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootCoreFrequency_sweepPropertyMeasurement_environment.ValueEnum(self._context.get('root.core.frequency_sweep.property.measurement_environment.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.core.frequency_sweep.property.measurement_environment.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.core.frequency_sweep.property.measurement_environment.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.core.frequency_sweep.property.measurement_environment.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.core.frequency_sweep.property.measurement_environment.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.core.frequency_sweep.property.measurement_environment.enum', list(new_val))


class RootCoreFrequency_sweepProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep.property'
        self.measurement_environment = RootCoreFrequency_sweepPropertyMeasurement_environment(self._context)
        self.fit_frequency_upper_bound = RootCoreFrequency_sweepPropertyFit_frequency_upper_bound(self._context)
        self.sweep_excitation_amplitude = RootCoreFrequency_sweepPropertySweep_excitation_amplitude(self._context)
        self.sweep_frequency_upper_bound = RootCoreFrequency_sweepPropertySweep_frequency_upper_bound(self._context)
        self.temperature = RootCoreFrequency_sweepPropertyTemperature(self._context)
        self.fit_frequency_lower_bound = RootCoreFrequency_sweepPropertyFit_frequency_lower_bound(self._context)
        self.sweep_frequency_lower_bound = RootCoreFrequency_sweepPropertySweep_frequency_lower_bound(self._context)
        self.sweep_free_vibration_amplitude = RootCoreFrequency_sweepPropertySweep_free_vibration_amplitude(self._context)
        self.new_excitation_frequency = RootCoreFrequency_sweepPropertyNew_excitation_frequency(self._context)
        self.amplitude_reduction = RootCoreFrequency_sweepPropertyAmplitude_reduction(self._context)
        self.sweep_data_points = RootCoreFrequency_sweepPropertySweep_data_points(self._context)
        self.analyzer_demodulator_bandwidth = RootCoreFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(self._context)
        self.amplitude_unit = RootCoreFrequency_sweepPropertyAmplitude_unit(self._context)
        self.new_spring_constant = RootCoreFrequency_sweepPropertyNew_spring_constant(self._context)
        self.frequency_selection_criteria = RootCoreFrequency_sweepPropertyFrequency_selection_criteria(self._context)


class RootCoreFrequency_sweep(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.frequency_sweep'
        self.property = RootCoreFrequency_sweepProperty(self._context)
        self.signal = RootCoreFrequency_sweepSignal(self._context)

    def start(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.start', *args)

    def do_sho_fit(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.do_sho_fit', *args)

    def invalidate_sweep_and_fit_data(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.invalidate_sweep_and_fit_data', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.abort', *args)

    def convert_and_emit_sweep_data(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.convert_and_emit_sweep_data', *args)

    def set_sweep_parameters(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.set_sweep_parameters', *args)

    def calculate_spring_constant(self, *args) -> Any:
        return self._context.call('root.core.frequency_sweep.calculate_spring_constant', *args)


class RootCoreCore_monitoring(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.core_monitoring'


class RootCoreSignal_analyzer1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.signal_analyzer1'


class RootCoreHv_amp_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.hv_amp_control'


class RootCorePosition_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.position_control'


class RootCoreSignal_registration(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core.signal_registration'


class RootCore(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.core'
        self.signal_registration = RootCoreSignal_registration(self._context)
        self.position_control = RootCorePosition_control(self._context)
        self.hv_amp_control = RootCoreHv_amp_control(self._context)
        self.signal_analyzer1 = RootCoreSignal_analyzer1(self._context)
        self.core_monitoring = RootCoreCore_monitoring(self._context)
        self.frequency_sweep = RootCoreFrequency_sweep(self._context)
        self.core_cantilever = RootCoreCore_cantilever(self._context)
        self.approach_motors_drive = RootCoreApproach_motors_drive(self._context)
        self.laser_align_drive_impl = RootCoreLaser_align_drive_impl(self._context)
        self.z_controller = RootCoreZ_controller(self._context)
        self.spectroscopy = RootCoreSpectroscopy(self._context)
        self.comp_dc = RootCoreComp_dc(self._context)
        self.core_options = RootCoreCore_options(self._context)
        self.ort = RootCoreOrt(self._context)
        self.approach = RootCoreApproach(self._context)
        self.thermal_tune = RootCoreThermal_tune(self._context)
        self.imaging = RootCoreImaging(self._context)
        self.signal_store = RootCoreSignal_store(self._context)
        self.acquisition = RootCoreAcquisition(self._context)
        self.scan_head_calibration = RootCoreScan_head_calibration(self._context)
        self.oscilloscope = RootCoreOscilloscope(self._context)
        self.direct_motor_control = RootCoreDirect_motor_control(self._context)
        self.core_environment = RootCoreCore_environment(self._context)
        self.converter_channel_correction = RootCoreConverter_channel_correction(self._context)


class RootLuApproachInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.busy'


class RootLuApproachInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.trigger'

    def start_adjust_tip_pos(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.start_adjust_tip_pos')

    def start_approach_afm(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.start_approach_afm')

    def start_pre_approach(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.start_pre_approach')

    def start_approach_steps(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.start_approach_steps')

    def start_approach_motor(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.start_approach_motor')

    def user_done(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.user_done')

    def user_abort(self) -> None:
        return self._context.call('root.lu.approach.instance.trigger.user_abort')


class RootLuApproachInstanceAttributeRelease_tip(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.release_tip'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.release_tip.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.release_tip.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.release_tip.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.release_tip.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.release_tip.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.release_tip.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.release_tip.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.release_tip.value', float(new_val))


class RootLuApproachInstanceAttributeStep_by_step_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_by_step_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.step_by_step_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_time.value', float(new_val))


class RootLuApproachInstanceAttributeStep_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_period'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_period.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_period.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_period.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_period.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.step_period.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.step_period.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_period.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_period.value', float(new_val))


class RootLuApproachInstanceAttributeStep_by_step_fine_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_fine_step_size_percentage.value', float(new_val))


class RootLuApproachInstanceAttributeCurrent_z_stage_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.current_z_stage_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.current_z_stage_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.current_z_stage_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.current_z_stage_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.current_z_stage_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.current_z_stage_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.current_z_stage_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.current_z_stage_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.current_z_stage_pos.value', float(new_val))


class RootLuApproachInstanceAttributeApproach_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.approach_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.approach_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos.value', float(new_val))


class RootLuApproachInstanceAttributeRetract_tip(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.retract_tip'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.retract_tip.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.retract_tip.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.retract_tip.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.retract_tip.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.retract_tip.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.retract_tip.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.retract_tip.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.retract_tip.value', float(new_val))


class RootLuApproachInstanceAttributeStep_by_step_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        tip_position_ignored = 2
        position_controlled = 0
        not_controlled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_by_step_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeStep_by_step_mode.ValueEnum(self._context.get('root.lu.approach.instance.attribute.step_by_step_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.step_by_step_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.step_by_step_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_mode.enum', list(new_val))


class RootLuApproachInstanceAttributeAfm_approach_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        continuous = 0
        step_by_step = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.afm_approach_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeAfm_approach_mode.ValueEnum(self._context.get('root.lu.approach.instance.attribute.afm_approach_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.afm_approach_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.afm_approach_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.afm_approach_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.afm_approach_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.afm_approach_mode.enum', list(new_val))


class RootLuApproachInstanceAttributeWithdraw_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.withdraw_steps'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.withdraw_steps.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.withdraw_steps.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.withdraw_steps.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.withdraw_steps.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.withdraw_steps.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.withdraw_steps.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.withdraw_steps.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.withdraw_steps.value', float(new_val))


class RootLuApproachInstanceAttributeApproach_result(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        timeout = 9
        limit_switch_error = 4
        user_abort = 5
        park_position = 8
        tip_pos_adjust_failed = 7
        end_of_travel = 2
        tip_pos_adjust_done = 6
        sensor_error = 3
        no_error = 0
        approach_done = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_result'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeApproach_result.ValueEnum(self._context.get('root.lu.approach.instance.attribute.approach_result.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.approach_result.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.approach_result.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.approach_result.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.approach_result.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.approach_result.enum', list(new_val))


class RootLuApproachInstanceAttributeApproach_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.approach_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.approach_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_speed.value', float(new_val))


class RootLuApproachInstanceAttributeApproach_pos_error(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_pos_error'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos_error.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos_error.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos_error.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos_error.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.approach_pos_error.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.approach_pos_error.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_pos_error.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_pos_error.value', float(new_val))


class RootLuApproachInstanceAttributeStep_by_step_slope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_by_step_slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.step_by_step_slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_slope.value', float(new_val))


class RootLuApproachInstanceAttributeApproach_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        max_out = 13
        user_abort = 12
        limit_failed = 10
        home_position_reached = 6
        cancel_dialog = 17
        approach_done = 3
        process_dialog = 16
        timeout = 18
        init_done = 14
        calibration_failed = 11
        approach_aborted = 4
        sensor_failed = 9
        move_toward = 8
        approaching = 2
        move_to_home_position = 5
        adjusting_tip_pos = 15
        move_away = 7
        idle = 0
        initializing = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeApproach_status.ValueEnum(self._context.get('root.lu.approach.instance.attribute.approach_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.approach_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.approach_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.approach_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.approach_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.approach_status.enum', list(new_val))


class RootLuApproachInstanceAttributeEnable_pre_approach_xycl_calibration(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.enable_pre_approach_xycl_calibration.value', float(new_val))


class RootLuApproachInstanceAttributeStepper_direction(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        forward = 0
        backward = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.stepper_direction'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeStepper_direction.ValueEnum(self._context.get('root.lu.approach.instance.attribute.stepper_direction.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.stepper_direction.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.stepper_direction.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.stepper_direction.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.stepper_direction.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.stepper_direction.enum', list(new_val))


class RootLuApproachInstanceAttributeApproach_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.approach_steps'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_steps.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_steps.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_steps.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_steps.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.approach_steps.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.approach_steps.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.approach_steps.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.approach_steps.value', float(new_val))


class RootLuApproachInstanceAttributeStep_by_step_coarse_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.approach.instance.attribute.step_by_step_coarse_step_size_percentage.value', float(new_val))


class RootLuApproachInstanceAttributeMotor_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        internal = 0
        external = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute.motor_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuApproachInstanceAttributeMotor_source.ValueEnum(self._context.get('root.lu.approach.instance.attribute.motor_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.approach.instance.attribute.motor_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.approach.instance.attribute.motor_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.approach.instance.attribute.motor_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.approach.instance.attribute.motor_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.approach.instance.attribute.motor_source.enum', list(new_val))


class RootLuApproachInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance.attribute'
        self.motor_source = RootLuApproachInstanceAttributeMotor_source(self._context)
        self.step_by_step_coarse_step_size_percentage = RootLuApproachInstanceAttributeStep_by_step_coarse_step_size_percentage(self._context)
        self.approach_steps = RootLuApproachInstanceAttributeApproach_steps(self._context)
        self.stepper_direction = RootLuApproachInstanceAttributeStepper_direction(self._context)
        self.enable_pre_approach_xycl_calibration = RootLuApproachInstanceAttributeEnable_pre_approach_xycl_calibration(self._context)
        self.approach_status = RootLuApproachInstanceAttributeApproach_status(self._context)
        self.step_by_step_slope = RootLuApproachInstanceAttributeStep_by_step_slope(self._context)
        self.approach_pos_error = RootLuApproachInstanceAttributeApproach_pos_error(self._context)
        self.approach_speed = RootLuApproachInstanceAttributeApproach_speed(self._context)
        self.approach_result = RootLuApproachInstanceAttributeApproach_result(self._context)
        self.withdraw_steps = RootLuApproachInstanceAttributeWithdraw_steps(self._context)
        self.afm_approach_mode = RootLuApproachInstanceAttributeAfm_approach_mode(self._context)
        self.step_by_step_mode = RootLuApproachInstanceAttributeStep_by_step_mode(self._context)
        self.retract_tip = RootLuApproachInstanceAttributeRetract_tip(self._context)
        self.approach_pos = RootLuApproachInstanceAttributeApproach_pos(self._context)
        self.current_z_stage_pos = RootLuApproachInstanceAttributeCurrent_z_stage_pos(self._context)
        self.step_by_step_fine_step_size_percentage = RootLuApproachInstanceAttributeStep_by_step_fine_step_size_percentage(self._context)
        self.step_period = RootLuApproachInstanceAttributeStep_period(self._context)
        self.step_by_step_time = RootLuApproachInstanceAttributeStep_by_step_time(self._context)
        self.release_tip = RootLuApproachInstanceAttributeRelease_tip(self._context)


class RootLuApproachInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach.instance'
        self.attribute = RootLuApproachInstanceAttribute(self._context)
        self.trigger = RootLuApproachInstanceTrigger(self._context)
        self.busy = RootLuApproachInstanceBusy(self._context)


class RootLuApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.approach'
        self.instance = RootLuApproachInstance(self._context)


class RootLuSystemInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.busy'


class RootLuSystemInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.trigger'

    def exit_spec(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_spec')

    def entry_scan(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_scan')

    def start_system_startup(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.start_system_startup')

    def motor_step(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_step')

    def entry_approach(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_approach')

    def exit_approach(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_approach')

    def exit_idle(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_idle')

    def entry_macro_cmd(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_macro_cmd')

    def force_motor_pos_update(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.force_motor_pos_update')

    def exit_macro_cmd(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_macro_cmd')

    def exit_litho(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_litho')

    def entry_litho(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_litho')

    def entry_idle(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_idle')

    def entry_uncal(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_uncal')

    def exit_uncal(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_uncal')

    def motor_set_pos_zero(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_set_pos_zero')

    def motor_reference(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_reference')

    def motor_stop(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_stop')

    def offset_xyz(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.offset_xyz')

    def motor_reference_and_move_back(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_reference_and_move_back')

    def motor_move(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.motor_move')

    def level_scanhead(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.level_scanhead')

    def entry_spec(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.entry_spec')

    def exit_scan(self) -> None:
        return self._context.call('root.lu.system.instance.trigger.exit_scan')


class RootLuSystemInstanceAttributeOperating_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fm_dynamic_afm = 11
        static_afm = 2
        resistivity_map = 6
        const_phase = 7
        lateral_force = 9
        phase_contrast = 4
        user_defined = 10
        force_modulation = 5
        stm = 1
        undefined = 0
        dynamic_afm = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.operating_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeOperating_mode.ValueEnum(self._context.get('root.lu.system.instance.attribute.operating_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.operating_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.operating_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.operating_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.operating_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.operating_mode.enum', list(new_val))


class RootLuSystemInstanceAttributeMotor_step_size(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.motor_step_size'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_step_size.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_step_size.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_step_size.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_step_size.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.motor_step_size.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.motor_step_size.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_step_size.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_step_size.value', float(new_val))


class RootLuSystemInstanceAttributeIdle_position_xy_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        image_center = 0
        keep_last_xy_pos = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.idle_position_xy_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeIdle_position_xy_mode.ValueEnum(self._context.get('root.lu.system.instance.attribute.idle_position_xy_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.idle_position_xy_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.idle_position_xy_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.idle_position_xy_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.idle_position_xy_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.idle_position_xy_mode.enum', list(new_val))


class RootLuSystemInstanceAttributeMotor_move_speed_factor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.motor_move_speed_factor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_move_speed_factor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_move_speed_factor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_move_speed_factor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_move_speed_factor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.motor_move_speed_factor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.motor_move_speed_factor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.motor_move_speed_factor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.motor_move_speed_factor.value', float(new_val))


class RootLuSystemInstanceAttributeSystem_state(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        internal = 7
        uncal = 0
        macro_cmd = 6
        idle = 1
        scan = 3
        litho = 5
        approach = 2
        spec = 4

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.system_state'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeSystem_state.ValueEnum(self._context.get('root.lu.system.instance.attribute.system_state.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.system_state.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.system_state.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.system_state.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.system_state.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.system_state.enum', list(new_val))


class RootLuSystemInstanceAttributeMemory_available(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.memory_available'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_available.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_available.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_available.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_available.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.memory_available.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.memory_available.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_available.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_available.value', float(new_val))


class RootLuSystemInstanceAttributeZ_axis_ctrl_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        position_drive = 1
        position_sensing = 2
        undefined = 0
        position_control = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.z_axis_ctrl_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeZ_axis_ctrl_mode.ValueEnum(self._context.get('root.lu.system.instance.attribute.z_axis_ctrl_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.z_axis_ctrl_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.z_axis_ctrl_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.z_axis_ctrl_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.z_axis_ctrl_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.z_axis_ctrl_mode.enum', list(new_val))


class RootLuSystemInstanceAttributeMemory_block_available(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.memory_block_available'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_block_available.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_block_available.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_block_available.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_block_available.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.memory_block_available.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.memory_block_available.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.memory_block_available.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.memory_block_available.value', float(new_val))


class RootLuSystemInstanceAttributeHi_res_ch4_input(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.hi_res_ch4_input'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch4_input.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch4_input.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch4_input.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch4_input.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.hi_res_ch4_input.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch4_input.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch4_input.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch4_input.value', float(new_val))


class RootLuSystemInstanceAttributeMeasurement_environment(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        air = 0
        liquid = 1
        vacuum = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.measurement_environment'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeMeasurement_environment.ValueEnum(self._context.get('root.lu.system.instance.attribute.measurement_environment.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.measurement_environment.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.measurement_environment.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.measurement_environment.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.measurement_environment.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.measurement_environment.enum', list(new_val))


class RootLuSystemInstanceAttributeIdle_position_z_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_controller_active = 0
        retract_tip = 1
        absolute_z_pos = 3
        keep_last_z_pos = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.idle_position_z_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeIdle_position_z_mode.ValueEnum(self._context.get('root.lu.system.instance.attribute.idle_position_z_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.idle_position_z_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.idle_position_z_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.idle_position_z_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.idle_position_z_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.idle_position_z_mode.enum', list(new_val))


class RootLuSystemInstanceAttributeIdle_position_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.idle_position_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_position_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_position_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_position_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_position_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.idle_position_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.idle_position_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_position_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_position_z.value', float(new_val))


class RootLuSystemInstanceAttributeOp_mode_kpfm_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.op_mode_kpfm_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeOp_mode_kpfm_enabled.ValueEnum(self._context.get('root.lu.system.instance.attribute.op_mode_kpfm_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.op_mode_kpfm_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.op_mode_kpfm_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.op_mode_kpfm_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.op_mode_kpfm_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.op_mode_kpfm_enabled.enum', list(new_val))


class RootLuSystemInstanceAttributeMotor_selection(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        motor_photodiode_lateral = 9
        motor_c = 3
        motor_b = 2
        motor_lens_gimbal = 11
        motor_beam_deflection_x = 7
        motor_beam_deflection_y = 8
        motor_approach = 0
        motor_a = 1
        motor_ptex = 5
        motor_ptey = 6
        motor_photodiode_normal = 10
        motor_focus = 4

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.motor_selection'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeMotor_selection.ValueEnum(self._context.get('root.lu.system.instance.attribute.motor_selection.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.motor_selection.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.motor_selection.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.motor_selection.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.motor_selection.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.motor_selection.enum', list(new_val))


class RootLuSystemInstanceAttributeHi_res_ch5_input(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.hi_res_ch5_input'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch5_input.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch5_input.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch5_input.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch5_input.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.hi_res_ch5_input.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch5_input.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.hi_res_ch5_input.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.hi_res_ch5_input.value', float(new_val))


class RootLuSystemInstanceAttributeMotor_move_direction(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.motor_move_direction'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeMotor_move_direction.ValueEnum(self._context.get('root.lu.system.instance.attribute.motor_move_direction.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.motor_move_direction.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.motor_move_direction.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.motor_move_direction.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.motor_move_direction.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.motor_move_direction.enum', list(new_val))


class RootLuSystemInstanceAttributeIdle_external_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.idle_external_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_external_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_external_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_external_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_external_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system.instance.attribute.idle_external_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system.instance.attribute.idle_external_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system.instance.attribute.idle_external_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system.instance.attribute.idle_external_z.value', float(new_val))


class RootLuSystemInstanceAttributeIdle_external_z_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_controller_active = 0
        retract_tip = 1
        absolute_z_pos = 3
        keep_last_z_pos = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute.idle_external_z_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystemInstanceAttributeIdle_external_z_mode.ValueEnum(self._context.get('root.lu.system.instance.attribute.idle_external_z_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system.instance.attribute.idle_external_z_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system.instance.attribute.idle_external_z_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system.instance.attribute.idle_external_z_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system.instance.attribute.idle_external_z_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system.instance.attribute.idle_external_z_mode.enum', list(new_val))


class RootLuSystemInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance.attribute'
        self.idle_external_z_mode = RootLuSystemInstanceAttributeIdle_external_z_mode(self._context)
        self.idle_external_z = RootLuSystemInstanceAttributeIdle_external_z(self._context)
        self.motor_move_direction = RootLuSystemInstanceAttributeMotor_move_direction(self._context)
        self.hi_res_ch5_input = RootLuSystemInstanceAttributeHi_res_ch5_input(self._context)
        self.motor_selection = RootLuSystemInstanceAttributeMotor_selection(self._context)
        self.op_mode_kpfm_enabled = RootLuSystemInstanceAttributeOp_mode_kpfm_enabled(self._context)
        self.idle_position_z = RootLuSystemInstanceAttributeIdle_position_z(self._context)
        self.idle_position_z_mode = RootLuSystemInstanceAttributeIdle_position_z_mode(self._context)
        self.measurement_environment = RootLuSystemInstanceAttributeMeasurement_environment(self._context)
        self.hi_res_ch4_input = RootLuSystemInstanceAttributeHi_res_ch4_input(self._context)
        self.memory_block_available = RootLuSystemInstanceAttributeMemory_block_available(self._context)
        self.z_axis_ctrl_mode = RootLuSystemInstanceAttributeZ_axis_ctrl_mode(self._context)
        self.memory_available = RootLuSystemInstanceAttributeMemory_available(self._context)
        self.system_state = RootLuSystemInstanceAttributeSystem_state(self._context)
        self.motor_move_speed_factor = RootLuSystemInstanceAttributeMotor_move_speed_factor(self._context)
        self.idle_position_xy_mode = RootLuSystemInstanceAttributeIdle_position_xy_mode(self._context)
        self.motor_step_size = RootLuSystemInstanceAttributeMotor_step_size(self._context)
        self.operating_mode = RootLuSystemInstanceAttributeOperating_mode(self._context)


class RootLuSystemInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system.instance'
        self.attribute = RootLuSystemInstanceAttribute(self._context)
        self.trigger = RootLuSystemInstanceTrigger(self._context)
        self.busy = RootLuSystemInstanceBusy(self._context)


class RootLuSystem(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system'
        self.instance = RootLuSystemInstance(self._context)


class RootLuAuto_alignmentInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.busy'


class RootLuAuto_alignmentInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.trigger'

    def start_optimization(self) -> None:
        return self._context.call('root.lu.auto_alignment.instance.trigger.start_optimization')

    def start_move_to_optical_center(self) -> None:
        return self._context.call('root.lu.auto_alignment.instance.trigger.start_move_to_optical_center')

    def start_search_algorithm(self) -> None:
        return self._context.call('root.lu.auto_alignment.instance.trigger.start_search_algorithm')

    def start_align(self) -> None:
        return self._context.call('root.lu.auto_alignment.instance.trigger.start_align')

    def user_abort(self) -> None:
        return self._context.call('root.lu.auto_alignment.instance.trigger.user_abort')


class RootLuAuto_alignmentInstanceAttributePte_optical_center_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.pte_optical_center_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_x.value', float(new_val))


class RootLuAuto_alignmentInstanceAttributeComponent_state(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        coarse_positioning_x = 4
        idle_not_positioned = 0
        searching = 3
        idle_positioned = 1
        optimizing = 6
        configuring = 2
        coarse_positioning_y = 5

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.component_state'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAuto_alignmentInstanceAttributeComponent_state.ValueEnum(self._context.get('root.lu.auto_alignment.instance.attribute.component_state.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.auto_alignment.instance.attribute.component_state.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.auto_alignment.instance.attribute.component_state.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.auto_alignment.instance.attribute.component_state.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.auto_alignment.instance.attribute.component_state.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.auto_alignment.instance.attribute.component_state.enum', list(new_val))


class RootLuAuto_alignmentInstanceAttributeReadout_optical_center_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.readout_optical_center_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_y.value', float(new_val))


class RootLuAuto_alignmentInstanceAttributeAlign_state(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        failed = 2
        running = 1
        aligned_successfully = 3
        idle = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.align_state'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAuto_alignmentInstanceAttributeAlign_state.ValueEnum(self._context.get('root.lu.auto_alignment.instance.attribute.align_state.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.auto_alignment.instance.attribute.align_state.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.auto_alignment.instance.attribute.align_state.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.auto_alignment.instance.attribute.align_state.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.auto_alignment.instance.attribute.align_state.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.auto_alignment.instance.attribute.align_state.enum', list(new_val))


class RootLuAuto_alignmentInstanceAttributeReadout_optical_center_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.readout_optical_center_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.readout_optical_center_x.value', float(new_val))


class RootLuAuto_alignmentInstanceAttributeSearch_algorithm(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        bottom_to_top_stepped = 2
        cantilever_between_two_reflecting_edges = 3
        rhombus_spiral = 1
        minimalistic = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.search_algorithm'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAuto_alignmentInstanceAttributeSearch_algorithm.ValueEnum(self._context.get('root.lu.auto_alignment.instance.attribute.search_algorithm.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.auto_alignment.instance.attribute.search_algorithm.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.auto_alignment.instance.attribute.search_algorithm.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.auto_alignment.instance.attribute.search_algorithm.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.auto_alignment.instance.attribute.search_algorithm.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.auto_alignment.instance.attribute.search_algorithm.enum', list(new_val))


class RootLuAuto_alignmentInstanceAttributePte_optical_center_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.pte_optical_center_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.auto_alignment.instance.attribute.pte_optical_center_y.value', float(new_val))


class RootLuAuto_alignmentInstanceAttributeCurrent_optic_component(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        focus = 3
        all = 0
        readout = 1
        detector = 5
        pte = 2
        beam_shifter = 4

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute.current_optic_component'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAuto_alignmentInstanceAttributeCurrent_optic_component.ValueEnum(self._context.get('root.lu.auto_alignment.instance.attribute.current_optic_component.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.auto_alignment.instance.attribute.current_optic_component.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.auto_alignment.instance.attribute.current_optic_component.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.auto_alignment.instance.attribute.current_optic_component.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.auto_alignment.instance.attribute.current_optic_component.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.auto_alignment.instance.attribute.current_optic_component.enum', list(new_val))


class RootLuAuto_alignmentInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance.attribute'
        self.current_optic_component = RootLuAuto_alignmentInstanceAttributeCurrent_optic_component(self._context)
        self.pte_optical_center_y = RootLuAuto_alignmentInstanceAttributePte_optical_center_y(self._context)
        self.search_algorithm = RootLuAuto_alignmentInstanceAttributeSearch_algorithm(self._context)
        self.readout_optical_center_x = RootLuAuto_alignmentInstanceAttributeReadout_optical_center_x(self._context)
        self.align_state = RootLuAuto_alignmentInstanceAttributeAlign_state(self._context)
        self.readout_optical_center_y = RootLuAuto_alignmentInstanceAttributeReadout_optical_center_y(self._context)
        self.component_state = RootLuAuto_alignmentInstanceAttributeComponent_state(self._context)
        self.pte_optical_center_x = RootLuAuto_alignmentInstanceAttributePte_optical_center_x(self._context)


class RootLuAuto_alignmentInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment.instance'
        self.attribute = RootLuAuto_alignmentInstanceAttribute(self._context)
        self.trigger = RootLuAuto_alignmentInstanceTrigger(self._context)
        self.busy = RootLuAuto_alignmentInstanceBusy(self._context)


class RootLuAuto_alignment(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.auto_alignment'
        self.instance = RootLuAuto_alignmentInstance(self._context)


class RootLuEvent_managerInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.busy'

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.event_manager.instance.busy.is_busy'))


class RootLuEvent_managerInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.start')

    def soft_event2_falling_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event2_falling_edge')

    def soft_event1_rising_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event1_rising_edge')

    def abort(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.abort')

    def stop(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.stop')

    def soft_event0_falling_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event0_falling_edge')

    def user_abort(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.user_abort')

    def soft_event2_rising_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event2_rising_edge')

    def soft_event1_falling_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event1_falling_edge')

    def soft_event0_rising_edge(self) -> None:
        return self._context.call('root.lu.event_manager.instance.trigger.soft_event0_rising_edge')


class RootLuEvent_managerInstanceAttributeStop_event_mask(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 33554432
        ramp_gen_maxz_done = 128
        ramp_gen_alternatez_done = 256
        z_ctrl_reached_min_z_true = 524288
        ramp_gen_test_done = 8192
        soft_event0_true = 16777216
        and_mask0_true = 268435456
        z_ctrl_reached_max_z_true = 1048576
        user_abort_event_true = 134217728
        all = -196609
        z_ctrl_reached_error_limit_true = 262144
        soft_event2_true = 67108864
        mem_sig_gen_done = 4096
        unused_done = 4
        comparator2_true = 1073741824
        ramp_gen_tipvoltage_done = 512
        timer_dbg1_done = 32768
        timer_proc0_done = 2048
        ramp_gen_positionx_done = 8
        ramp_gen_positiony_done = 16
        data_sampling_done = 2
        data_capture_done = 1
        ramp_gen_user4_done = 16384
        ramp_gen_approach_done = 1024
        ramp_gen_planez_done = 32
        ext_event1_true = 8388608
        comparator1_true = 536870912
        none = 0
        ramp_gen_ctrlz_done = 64
        ext_event0_true = 4194304
        comparator3_true = -2147483648

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.stop_event_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuEvent_managerInstanceAttributeStop_event_mask.ValueEnum(self._context.get('root.lu.event_manager.instance.attribute.stop_event_mask.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.event_manager.instance.attribute.stop_event_mask.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.stop_event_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.stop_event_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.stop_event_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.stop_event_mask.enum', list(new_val))


class RootLuEvent_managerInstanceAttributeEvent_vector_snapshot(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 33554432
        ramp_gen_maxz_done = 128
        ramp_gen_alternatez_done = 256
        z_ctrl_reached_min_z_true = 524288
        ramp_gen_test_done = 8192
        soft_event0_true = 16777216
        and_mask0_true = 268435456
        z_ctrl_reached_max_z_true = 1048576
        user_abort_event_true = 134217728
        all = -196609
        z_ctrl_reached_error_limit_true = 262144
        soft_event2_true = 67108864
        mem_sig_gen_done = 4096
        unused_done = 4
        comparator2_true = 1073741824
        ramp_gen_tipvoltage_done = 512
        timer_dbg1_done = 32768
        timer_proc0_done = 2048
        ramp_gen_positionx_done = 8
        ramp_gen_positiony_done = 16
        data_sampling_done = 2
        data_capture_done = 1
        ramp_gen_user4_done = 16384
        ramp_gen_approach_done = 1024
        ramp_gen_planez_done = 32
        ext_event1_true = 8388608
        comparator1_true = 536870912
        none = 0
        ramp_gen_ctrlz_done = 64
        ext_event0_true = 4194304
        comparator3_true = -2147483648

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.event_vector_snapshot'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuEvent_managerInstanceAttributeEvent_vector_snapshot.ValueEnum(self._context.get('root.lu.event_manager.instance.attribute.event_vector_snapshot.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector_snapshot.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.event_vector_snapshot.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector_snapshot.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.event_vector_snapshot.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector_snapshot.enum', list(new_val))


class RootLuEvent_managerInstanceAttributeAnd_mask0(wrap.CmdTreeProp):

    class ValueMask(enum.IntEnum):
        soft_event1_true = 33554432
        ramp_gen_maxz_done = 128
        ramp_gen_alternatez_done = 256
        z_ctrl_reached_min_z_true = 524288
        ramp_gen_test_done = 8192
        soft_event0_true = 16777216
        and_mask0_true = 268435456
        z_ctrl_reached_max_z_true = 1048576
        user_abort_event_true = 134217728
        all = 4294770687.0
        z_ctrl_reached_error_limit_true = 262144
        soft_event2_true = 67108864
        mem_sig_gen_done = 4096
        unused_done = 4
        comparator2_true = 1073741824
        ramp_gen_tipvoltage_done = 512
        timer_dbg1_done = 32768
        timer_proc0_done = 2048
        ramp_gen_positionx_done = 8
        ramp_gen_positiony_done = 16
        data_sampling_done = 2
        data_capture_done = 1
        ramp_gen_user4_done = 16384
        ramp_gen_approach_done = 1024
        ramp_gen_planez_done = 32
        ext_event1_true = 8388608
        comparator1_true = 536870912
        none = 0
        ramp_gen_ctrlz_done = 64
        ext_event0_true = 4194304
        comparator3_true = 2147483648.0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.and_mask0'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.and_mask0.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.and_mask0.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.and_mask0.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.and_mask0.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.event_manager.instance.attribute.and_mask0.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.event_manager.instance.attribute.and_mask0.unit', str(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.and_mask0.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.and_mask0.enum', list(new_val))

    @property
    def value(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.and_mask0.value_raw'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.and_mask0.value_raw', int(new_val))


class RootLuEvent_managerInstanceAttributeStart_mask(wrap.CmdTreeProp):

    class ValueMask(enum.IntEnum):
        ramp_gen_positiony = 16
        ramp_gen_planez = 32
        data_sampling = 2
        ramp_gen_ctrlz = 64
        data_capture = 1
        all = 65535
        ramp_gen_alternatez = 256
        ramp_gen_test = 8192
        ramp_gen_approach = 1024
        mem_sig_gen = 4096
        ramp_gen_maxz = 128
        none = 0
        ramp_gen_user4 = 16384
        unused = 4
        ramp_gen_tipvoltage = 512
        timer_dbg1 = 32768
        timer_proc0 = 2048
        ramp_gen_positionx = 8

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.start_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.start_mask.value_raw'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.start_mask.value_raw', int(new_val))

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.start_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.start_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.start_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.start_mask.enum', list(new_val))


class RootLuEvent_managerInstanceAttributeAbort_event_mask(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 33554432
        ramp_gen_maxz_done = 128
        ramp_gen_alternatez_done = 256
        z_ctrl_reached_min_z_true = 524288
        ramp_gen_test_done = 8192
        soft_event0_true = 16777216
        and_mask0_true = 268435456
        z_ctrl_reached_max_z_true = 1048576
        user_abort_event_true = 134217728
        all = -196609
        z_ctrl_reached_error_limit_true = 262144
        soft_event2_true = 67108864
        mem_sig_gen_done = 4096
        unused_done = 4
        comparator2_true = 1073741824
        ramp_gen_tipvoltage_done = 512
        timer_dbg1_done = 32768
        timer_proc0_done = 2048
        ramp_gen_positionx_done = 8
        ramp_gen_positiony_done = 16
        data_sampling_done = 2
        data_capture_done = 1
        ramp_gen_user4_done = 16384
        ramp_gen_approach_done = 1024
        ramp_gen_planez_done = 32
        ext_event1_true = 8388608
        comparator1_true = 536870912
        none = 0
        ramp_gen_ctrlz_done = 64
        ext_event0_true = 4194304
        comparator3_true = -2147483648

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.abort_event_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuEvent_managerInstanceAttributeAbort_event_mask.ValueEnum(self._context.get('root.lu.event_manager.instance.attribute.abort_event_mask.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.event_manager.instance.attribute.abort_event_mask.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.abort_event_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.abort_event_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.abort_event_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.abort_event_mask.enum', list(new_val))


class RootLuEvent_managerInstanceAttributeObject_idle(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.object_idle'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_idle.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_idle.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_idle.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_idle.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.event_manager.instance.attribute.object_idle.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.event_manager.instance.attribute.object_idle.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_idle.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_idle.value', float(new_val))


class RootLuEvent_managerInstanceAttributeObject_queue_size(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.object_queue_size'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_queue_size.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_queue_size.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_queue_size.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_queue_size.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.event_manager.instance.attribute.object_queue_size.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.event_manager.instance.attribute.object_queue_size.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.event_manager.instance.attribute.object_queue_size.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.event_manager.instance.attribute.object_queue_size.value', float(new_val))


class RootLuEvent_managerInstanceAttributeEvent_vector(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 33554432
        ramp_gen_maxz_done = 128
        ramp_gen_alternatez_done = 256
        z_ctrl_reached_min_z_true = 524288
        ramp_gen_test_done = 8192
        soft_event0_true = 16777216
        and_mask0_true = 268435456
        z_ctrl_reached_max_z_true = 1048576
        user_abort_event_true = 134217728
        all = -196609
        z_ctrl_reached_error_limit_true = 262144
        soft_event2_true = 67108864
        mem_sig_gen_done = 4096
        unused_done = 4
        comparator2_true = 1073741824
        ramp_gen_tipvoltage_done = 512
        timer_dbg1_done = 32768
        timer_proc0_done = 2048
        ramp_gen_positionx_done = 8
        ramp_gen_positiony_done = 16
        data_sampling_done = 2
        data_capture_done = 1
        ramp_gen_user4_done = 16384
        ramp_gen_approach_done = 1024
        ramp_gen_planez_done = 32
        ext_event1_true = 8388608
        comparator1_true = 536870912
        none = 0
        ramp_gen_ctrlz_done = 64
        ext_event0_true = 4194304
        comparator3_true = -2147483648

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.event_vector'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuEvent_managerInstanceAttributeEvent_vector.ValueEnum(self._context.get('root.lu.event_manager.instance.attribute.event_vector.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.event_vector.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.event_vector.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.event_vector.enum', list(new_val))


class RootLuEvent_managerInstanceAttributeStop_mask(wrap.CmdTreeProp):

    class ValueMask(enum.IntEnum):
        ramp_gen_positiony = 16
        ramp_gen_planez = 32
        data_sampling = 2
        ramp_gen_ctrlz = 64
        data_capture = 1
        all = 65535
        ramp_gen_alternatez = 256
        ramp_gen_test = 8192
        ramp_gen_approach = 1024
        mem_sig_gen = 4096
        ramp_gen_maxz = 128
        none = 0
        ramp_gen_user4 = 16384
        unused = 4
        ramp_gen_tipvoltage = 512
        timer_dbg1 = 32768
        timer_proc0 = 2048
        ramp_gen_positionx = 8

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute.stop_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.stop_mask.value_raw'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.stop_mask.value_raw', int(new_val))

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.event_manager.instance.attribute.stop_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.event_manager.instance.attribute.stop_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.event_manager.instance.attribute.stop_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.event_manager.instance.attribute.stop_mask.enum', list(new_val))


class RootLuEvent_managerInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance.attribute'
        self.stop_mask = RootLuEvent_managerInstanceAttributeStop_mask(self._context)
        self.event_vector = RootLuEvent_managerInstanceAttributeEvent_vector(self._context)
        self.object_queue_size = RootLuEvent_managerInstanceAttributeObject_queue_size(self._context)
        self.object_idle = RootLuEvent_managerInstanceAttributeObject_idle(self._context)
        self.abort_event_mask = RootLuEvent_managerInstanceAttributeAbort_event_mask(self._context)
        self.start_mask = RootLuEvent_managerInstanceAttributeStart_mask(self._context)
        self.and_mask0 = RootLuEvent_managerInstanceAttributeAnd_mask0(self._context)
        self.event_vector_snapshot = RootLuEvent_managerInstanceAttributeEvent_vector_snapshot(self._context)
        self.stop_event_mask = RootLuEvent_managerInstanceAttributeStop_event_mask(self._context)


class RootLuEvent_managerInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager.instance'
        self.attribute = RootLuEvent_managerInstanceAttribute(self._context)
        self.trigger = RootLuEvent_managerInstanceTrigger(self._context)
        self.busy = RootLuEvent_managerInstanceBusy(self._context)


class RootLuEvent_manager(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.event_manager'
        self.instance = RootLuEvent_managerInstance(self._context)


class RootLuLithoInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.busy'


class RootLuLithoInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.trigger'

    def next_cmd_item(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.next_cmd_item')

    def user_abort(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.user_abort')

    def move_to_abs_xy_pos(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.move_to_abs_xy_pos')

    def end_sequence(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.end_sequence')

    def start_sequence(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.start_sequence')

    def first_cmd_item(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.first_cmd_item')

    def move_to_z(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.move_to_z')

    def make_pause(self) -> None:
        return self._context.call('root.lu.litho.instance.trigger.make_pause')


class RootLuLithoInstanceAttributeZ_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.z_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.z_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.z_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.z_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.z_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.z_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.z_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.z_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.z_move_speed.value', float(new_val))


class RootLuLithoInstanceAttributeAbsolute_y_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.absolute_y_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_y_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_y_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_y_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_y_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.absolute_y_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.absolute_y_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_y_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_y_pos.value', float(new_val))


class RootLuLithoInstanceAttributePause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.pause_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.pause_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.pause_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.pause_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.pause_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.pause_time.value', float(new_val))


class RootLuLithoInstanceAttributeXy_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.xy_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.xy_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.xy_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.xy_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.xy_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.xy_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.xy_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.xy_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.xy_move_speed.value', float(new_val))


class RootLuLithoInstanceAttributeOp_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        user = 0
        static_afm = 2
        z_modulation = 4
        stm = 1
        dynamic_afm = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.op_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuLithoInstanceAttributeOp_mode.ValueEnum(self._context.get('root.lu.litho.instance.attribute.op_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.litho.instance.attribute.op_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.litho.instance.attribute.op_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.litho.instance.attribute.op_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.litho.instance.attribute.op_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.litho.instance.attribute.op_mode.enum', list(new_val))


class RootLuLithoInstanceAttributeMove_z_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.move_z_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.move_z_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.move_z_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.move_z_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.move_z_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.move_z_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.move_z_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.move_z_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.move_z_pos.value', float(new_val))


class RootLuLithoInstanceAttributeMod_rel_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.mod_rel_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.mod_rel_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.mod_rel_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.mod_rel_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.mod_rel_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.mod_rel_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.mod_rel_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.mod_rel_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.mod_rel_value.value', float(new_val))


class RootLuLithoInstanceAttributeAbsolute_x_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute.absolute_x_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_x_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_x_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_x_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_x_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.litho.instance.attribute.absolute_x_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.litho.instance.attribute.absolute_x_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.litho.instance.attribute.absolute_x_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.litho.instance.attribute.absolute_x_pos.value', float(new_val))


class RootLuLithoInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance.attribute'
        self.absolute_x_pos = RootLuLithoInstanceAttributeAbsolute_x_pos(self._context)
        self.mod_rel_value = RootLuLithoInstanceAttributeMod_rel_value(self._context)
        self.move_z_pos = RootLuLithoInstanceAttributeMove_z_pos(self._context)
        self.op_mode = RootLuLithoInstanceAttributeOp_mode(self._context)
        self.xy_move_speed = RootLuLithoInstanceAttributeXy_move_speed(self._context)
        self.pause_time = RootLuLithoInstanceAttributePause_time(self._context)
        self.absolute_y_pos = RootLuLithoInstanceAttributeAbsolute_y_pos(self._context)
        self.z_move_speed = RootLuLithoInstanceAttributeZ_move_speed(self._context)


class RootLuLithoInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho.instance'
        self.attribute = RootLuLithoInstanceAttribute(self._context)
        self.trigger = RootLuLithoInstanceTrigger(self._context)
        self.busy = RootLuLithoInstanceBusy(self._context)


class RootLuLitho(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.litho'
        self.instance = RootLuLithoInstance(self._context)


class RootLuOscilloscopeInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.busy'

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.oscilloscope.instance.busy.is_busy'))


class RootLuOscilloscopeInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.oscilloscope.instance.trigger.start')

    def toggle_debug_logging(self) -> None:
        return self._context.call('root.lu.oscilloscope.instance.trigger.toggle_debug_logging')

    def stop(self) -> None:
        return self._context.call('root.lu.oscilloscope.instance.trigger.stop')

    def abort(self) -> None:
        return self._context.call('root.lu.oscilloscope.instance.trigger.abort')


class RootLuOscilloscopeInstanceAttributeHi_res_input_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.attribute.hi_res_input_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.oscilloscope.instance.attribute.hi_res_input_vec.vector', list(new_val))


class RootLuOscilloscopeInstanceAttributeFast_input_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.attribute.fast_input_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.fast_input_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.fast_input_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.fast_input_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.fast_input_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.oscilloscope.instance.attribute.fast_input_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.oscilloscope.instance.attribute.fast_input_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.oscilloscope.instance.attribute.fast_input_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.oscilloscope.instance.attribute.fast_input_vec.vector', list(new_val))


class RootLuOscilloscopeInstanceAttributeCapture_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.attribute.capture_period'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_period.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_period.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_period.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_period.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.oscilloscope.instance.attribute.capture_period.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_period.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_period.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_period.value', float(new_val))


class RootLuOscilloscopeInstanceAttributeCapture_duration(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.attribute.capture_duration'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_duration.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_duration.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_duration.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_duration.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.oscilloscope.instance.attribute.capture_duration.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_duration.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.oscilloscope.instance.attribute.capture_duration.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.oscilloscope.instance.attribute.capture_duration.value', float(new_val))


class RootLuOscilloscopeInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance.attribute'
        self.capture_duration = RootLuOscilloscopeInstanceAttributeCapture_duration(self._context)
        self.capture_period = RootLuOscilloscopeInstanceAttributeCapture_period(self._context)
        self.fast_input_vec = RootLuOscilloscopeInstanceAttributeFast_input_vec(self._context)
        self.hi_res_input_vec = RootLuOscilloscopeInstanceAttributeHi_res_input_vec(self._context)


class RootLuOscilloscopeInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope.instance'
        self.attribute = RootLuOscilloscopeInstanceAttribute(self._context)
        self.trigger = RootLuOscilloscopeInstanceTrigger(self._context)
        self.busy = RootLuOscilloscopeInstanceBusy(self._context)


class RootLuOscilloscope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.oscilloscope'
        self.instance = RootLuOscilloscopeInstance(self._context)


class RootLuData_acquisitionInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.busy'

    @property
    def is_sampling(self) -> bool:
        return bool(self._context.call('root.lu.data_acquisition.instance.busy.is_sampling'))

    @property
    def is_capturing(self) -> bool:
        return bool(self._context.call('root.lu.data_acquisition.instance.busy.is_capturing'))


class RootLuData_acquisitionInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.trigger'

    def background_capture_start(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.background_capture_start')

    def sampler_prepare(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.sampler_prepare')

    def capture_start(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.capture_start')

    def background_sampler_start(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.background_sampler_start')

    def capture_start_data_simulation(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.capture_start_data_simulation')

    def capture_trim_data_storage(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.capture_trim_data_storage')

    def capture_prepare(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.capture_prepare')

    def abort_all(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.abort_all')

    def sampler_start_data_simulation(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.sampler_start_data_simulation')

    def sampler_start(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.sampler_start')

    def sampler_init_phase_mode(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.sampler_init_phase_mode')

    def sampler_trim_data_storage(self) -> None:
        return self._context.call('root.lu.data_acquisition.instance.trigger.sampler_trim_data_storage')


class RootLuData_acquisitionInstanceAttributeActive_sampler_set(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.active_sampler_set'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_sampler_set.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_sampler_set.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_sampler_set.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_sampler_set.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.active_sampler_set.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_sampler_set.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_sampler_set.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_sampler_set.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_datapoints.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeNumber_of_sampler_sets(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.number_of_sampler_sets'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_sampler_sets.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_channel_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_channel_mask.value', float(new_val))


class RootLuData_acquisitionInstanceAttributePhase_mode_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.phase_mode_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_mode_enabled.value', float(new_val))


class RootLuData_acquisitionInstanceAttributePhase_sampler_data_rate_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_data_rate_vec.vector', list(new_val))


class RootLuData_acquisitionInstanceAttributePhase_sampler_end_datapoint_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_end_datapoint_vec.vector', list(new_val))


class RootLuData_acquisitionInstanceAttributePhase_sampler_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.phase_sampler_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_sampler_group_id.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_auto_set_filter_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_auto_set_filter_mode.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_data_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_data_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_data_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_data_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_data_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_data_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_data_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_data_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_data_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_data_rate.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_channel_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_channel_mask'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_channel_mask.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_channel_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_channel_mask.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_filter_size(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_filter_size'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_size.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_size.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_size.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_size.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_size.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_size.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_size.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_size.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_filter_type(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        window_hamming = 1
        window_rectangular = 0
        window_nuttall = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_filter_type'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_filter_type.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_type.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_type.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_type.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_type.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_type.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_type.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_filter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        filter_userdefined = 0
        low_pass_2_k_hz = 5
        low_pass_50_hz = 15
        low_pass_20_k_hz = 8
        low_pass_500_hz = 3
        low_pass_10_hz = 13
        low_pass_50_k_hz = 9
        low_pass_200_hz = 2
        low_pass_100_k_hz = 10
        low_pass_5_k_hz = 6
        low_pass_5_hz = 12
        low_pass_20_hz = 14
        low_pass_100_hz = 1
        low_pass_1_k_hz = 4
        low_pass_10_k_hz = 7

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_filter_mode.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_mode.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch2_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch2_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch2_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch1_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch1_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch1_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_ch0_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_free_wave = 6
        ort_excitation = 5
        analyzer2_reference = 4
        ctrl_z_out = 7
        analyzer1_reference = 3
        in_deflection = 0
        ctrl_w_out = 8
        in2 = 1
        in_user = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_fast_ch0_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch0_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch2_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch2_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch2_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch1_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch1_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch1_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch3_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch3_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch3_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch4_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch4_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch4_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch7_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch7_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch7_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch4_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch4_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch4_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch_input_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch_input_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch_input_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch_input_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch_input_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch_input_vec.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch7_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch7_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch7_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeNumber_of_capture_sets(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.number_of_capture_sets'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.number_of_capture_sets.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_group_id.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeActive_capture_set(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.active_capture_set'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_capture_set.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_capture_set.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_capture_set.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_capture_set.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.active_capture_set.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_capture_set.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.active_capture_set.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.active_capture_set.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_datapoints.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch0_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch0_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch0_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_trigger_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        internal_timer = 0
        external_trigger = 1
        num_trigger_modes = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_trigger_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_trigger_mode.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_trigger_mode.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_group_id.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_group_id.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch6_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch6_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch6_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch6_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch6_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch6_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch5_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch5_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_hi_res_ch5_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch5_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch5_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch5_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributePhase_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.phase_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.phase_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.phase_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.phase_count.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_ch1_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_free_wave = 6
        ort_excitation = 5
        analyzer2_reference = 4
        ctrl_z_out = 7
        analyzer1_reference = 3
        in_deflection = 0
        ctrl_w_out = 8
        in2 = 1
        in_user = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_fast_ch1_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch1_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch0_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch0_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch0_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch_input_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch_input_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch_input_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch_input_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch_input_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch_input_vec.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeSampler_filter_cutoff(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.sampler_filter_cutoff.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_datapoints.value', float(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch3_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch3_input.ValueEnum(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_hi_res_ch3_input.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_ch_input_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_free_wave = 6
        ort_excitation = 5
        analyzer2_reference = 4
        ctrl_z_out = 7
        analyzer1_reference = 3
        in_deflection = 0
        ctrl_w_out = 8
        in2 = 1
        in_user = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_ch_input_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch_input_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch_input_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_ch_input_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_ch_input_vec.enum', list(new_val))


class RootLuData_acquisitionInstanceAttributeCapture_fast_sampling_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.data_acquisition.instance.attribute.capture_fast_sampling_rate.value', float(new_val))


class RootLuData_acquisitionInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance.attribute'
        self.capture_fast_sampling_rate = RootLuData_acquisitionInstanceAttributeCapture_fast_sampling_rate(self._context)
        self.capture_fast_ch_input_vec = RootLuData_acquisitionInstanceAttributeCapture_fast_ch_input_vec(self._context)
        self.capture_hi_res_ch3_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch3_input(self._context)
        self.capture_fast_datapoints = RootLuData_acquisitionInstanceAttributeCapture_fast_datapoints(self._context)
        self.sampler_filter_cutoff = RootLuData_acquisitionInstanceAttributeSampler_filter_cutoff(self._context)
        self.capture_hi_res_ch_input_vec = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch_input_vec(self._context)
        self.capture_hi_res_ch0_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch0_input(self._context)
        self.capture_fast_ch1_input = RootLuData_acquisitionInstanceAttributeCapture_fast_ch1_input(self._context)
        self.phase_count = RootLuData_acquisitionInstanceAttributePhase_count(self._context)
        self.capture_hi_res_ch5_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch5_input(self._context)
        self.sampler_hi_res_ch5_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch5_input(self._context)
        self.capture_hi_res_ch6_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch6_input(self._context)
        self.sampler_hi_res_ch6_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch6_input(self._context)
        self.capture_fast_group_id = RootLuData_acquisitionInstanceAttributeCapture_fast_group_id(self._context)
        self.sampler_group_id = RootLuData_acquisitionInstanceAttributeSampler_group_id(self._context)
        self.sampler_trigger_mode = RootLuData_acquisitionInstanceAttributeSampler_trigger_mode(self._context)
        self.sampler_hi_res_ch0_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch0_input(self._context)
        self.sampler_datapoints = RootLuData_acquisitionInstanceAttributeSampler_datapoints(self._context)
        self.active_capture_set = RootLuData_acquisitionInstanceAttributeActive_capture_set(self._context)
        self.capture_hi_res_group_id = RootLuData_acquisitionInstanceAttributeCapture_hi_res_group_id(self._context)
        self.number_of_capture_sets = RootLuData_acquisitionInstanceAttributeNumber_of_capture_sets(self._context)
        self.capture_hi_res_ch7_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch7_input(self._context)
        self.sampler_hi_res_ch_input_vec = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch_input_vec(self._context)
        self.capture_hi_res_ch4_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch4_input(self._context)
        self.sampler_hi_res_ch7_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch7_input(self._context)
        self.sampler_hi_res_ch4_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch4_input(self._context)
        self.sampler_hi_res_ch3_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch3_input(self._context)
        self.capture_hi_res_ch1_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch1_input(self._context)
        self.sampler_hi_res_ch2_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch2_input(self._context)
        self.capture_fast_ch0_input = RootLuData_acquisitionInstanceAttributeCapture_fast_ch0_input(self._context)
        self.sampler_hi_res_ch1_input = RootLuData_acquisitionInstanceAttributeSampler_hi_res_ch1_input(self._context)
        self.capture_hi_res_ch2_input = RootLuData_acquisitionInstanceAttributeCapture_hi_res_ch2_input(self._context)
        self.sampler_filter_mode = RootLuData_acquisitionInstanceAttributeSampler_filter_mode(self._context)
        self.sampler_filter_type = RootLuData_acquisitionInstanceAttributeSampler_filter_type(self._context)
        self.sampler_filter_size = RootLuData_acquisitionInstanceAttributeSampler_filter_size(self._context)
        self.capture_hi_res_channel_mask = RootLuData_acquisitionInstanceAttributeCapture_hi_res_channel_mask(self._context)
        self.sampler_channel_mask = RootLuData_acquisitionInstanceAttributeSampler_channel_mask(self._context)
        self.sampler_data_rate = RootLuData_acquisitionInstanceAttributeSampler_data_rate(self._context)
        self.sampler_auto_set_filter_mode = RootLuData_acquisitionInstanceAttributeSampler_auto_set_filter_mode(self._context)
        self.phase_sampler_group_id = RootLuData_acquisitionInstanceAttributePhase_sampler_group_id(self._context)
        self.phase_sampler_end_datapoint_vec = RootLuData_acquisitionInstanceAttributePhase_sampler_end_datapoint_vec(self._context)
        self.phase_sampler_data_rate_vec = RootLuData_acquisitionInstanceAttributePhase_sampler_data_rate_vec(self._context)
        self.phase_mode_enabled = RootLuData_acquisitionInstanceAttributePhase_mode_enabled(self._context)
        self.capture_fast_channel_mask = RootLuData_acquisitionInstanceAttributeCapture_fast_channel_mask(self._context)
        self.number_of_sampler_sets = RootLuData_acquisitionInstanceAttributeNumber_of_sampler_sets(self._context)
        self.capture_hi_res_datapoints = RootLuData_acquisitionInstanceAttributeCapture_hi_res_datapoints(self._context)
        self.active_sampler_set = RootLuData_acquisitionInstanceAttributeActive_sampler_set(self._context)


class RootLuData_acquisitionInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition.instance'
        self.attribute = RootLuData_acquisitionInstanceAttribute(self._context)
        self.trigger = RootLuData_acquisitionInstanceTrigger(self._context)
        self.busy = RootLuData_acquisitionInstanceBusy(self._context)


class RootLuData_acquisition(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.data_acquisition'
        self.instance = RootLuData_acquisitionInstance(self._context)


class RootLuIsostageInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.busy'


class RootLuIsostageInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.trigger'

    def test_connection(self) -> None:
        return self._context.call('root.lu.isostage.instance.trigger.test_connection')

    def setup_event_counter(self) -> None:
        return self._context.call('root.lu.isostage.instance.trigger.setup_event_counter')

    def clear_event_counter(self) -> None:
        return self._context.call('root.lu.isostage.instance.trigger.clear_event_counter')

    def update_settings(self) -> None:
        return self._context.call('root.lu.isostage.instance.trigger.update_settings')


class RootLuIsostageInstanceAttributeIsolation_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        active = 0
        off_or_defined_by_user_switch = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.attribute.isolation_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuIsostageInstanceAttributeIsolation_mode.ValueEnum(self._context.get('root.lu.isostage.instance.attribute.isolation_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.isostage.instance.attribute.isolation_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.isostage.instance.attribute.isolation_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.isostage.instance.attribute.isolation_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.isostage.instance.attribute.isolation_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.isostage.instance.attribute.isolation_mode.enum', list(new_val))


class RootLuIsostageInstanceAttributeIs_connected(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.attribute.is_connected'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.is_connected.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.is_connected.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.is_connected.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.is_connected.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.isostage.instance.attribute.is_connected.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.isostage.instance.attribute.is_connected.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.is_connected.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.is_connected.value', float(new_val))


class RootLuIsostageInstanceAttributeEvent_counter(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.attribute.event_counter'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.event_counter.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.event_counter.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.event_counter.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.event_counter.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.isostage.instance.attribute.event_counter.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.isostage.instance.attribute.event_counter.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.event_counter.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.event_counter.value', float(new_val))


class RootLuIsostageInstanceAttributeOverload_sensitivity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.attribute.overload_sensitivity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.overload_sensitivity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.overload_sensitivity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.overload_sensitivity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.overload_sensitivity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.isostage.instance.attribute.overload_sensitivity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.isostage.instance.attribute.overload_sensitivity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.isostage.instance.attribute.overload_sensitivity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.isostage.instance.attribute.overload_sensitivity.value', float(new_val))


class RootLuIsostageInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance.attribute'
        self.overload_sensitivity = RootLuIsostageInstanceAttributeOverload_sensitivity(self._context)
        self.event_counter = RootLuIsostageInstanceAttributeEvent_counter(self._context)
        self.is_connected = RootLuIsostageInstanceAttributeIs_connected(self._context)
        self.isolation_mode = RootLuIsostageInstanceAttributeIsolation_mode(self._context)


class RootLuIsostageInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage.instance'
        self.attribute = RootLuIsostageInstanceAttribute(self._context)
        self.trigger = RootLuIsostageInstanceTrigger(self._context)
        self.busy = RootLuIsostageInstanceBusy(self._context)


class RootLuIsostage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.isostage'
        self.instance = RootLuIsostageInstance(self._context)


class RootLuSpecInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.busy'


class RootLuSpecInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.spec.instance.trigger.start')

    def pause(self) -> None:
        return self._context.call('root.lu.spec.instance.trigger.pause')

    def resume_last_point(self) -> None:
        return self._context.call('root.lu.spec.instance.trigger.resume_last_point')

    def resume_next_point(self) -> None:
        return self._context.call('root.lu.spec.instance.trigger.resume_next_point')

    def user_abort(self) -> None:
        return self._context.call('root.lu.spec.instance.trigger.user_abort')


class RootLuSpecInstanceAttributeBwd_mod_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_mod_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_mod_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_range.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_mod_stop_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_mod_stop_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_value.value', float(new_val))


class RootLuSpecInstanceAttributeSpec_end_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_controller_active = 1
        keep_last_z_pos = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.spec_end_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeSpec_end_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.spec_end_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.spec_end_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.spec_end_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.spec_end_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.spec_end_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.spec_end_mode.enum', list(new_val))


class RootLuSpecInstanceAttributePhase_bwd_pause_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_bwd_pause_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_pause_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_pause_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_pause_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_pause_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_bwd_pause_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_pause_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_pause_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_pause_rate.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_mod_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_mod_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_mod_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_range.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_mod_stop_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_mod_stop_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_value.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_pause_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_off = 0
        z_on = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_pause_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeFwd_pause_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.fwd_pause_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.fwd_pause_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.fwd_pause_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_mode.enum', list(new_val))


class RootLuSpecInstanceAttributeModulation_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        tip_voltage = 1
        external_z = 2
        position_z = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.modulation_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeModulation_output.ValueEnum(self._context.get('root.lu.spec.instance.attribute.modulation_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.modulation_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.modulation_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.modulation_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.modulation_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.modulation_output.enum', list(new_val))


class RootLuSpecInstanceAttributeFwd_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_datapoints.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_mod_stop_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_greater_than = 1
        is_less_than = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_mod_stop_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeBwd_mod_stop_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.bwd_mod_stop_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_stop_mode.enum', list(new_val))


class RootLuSpecInstanceAttributeAuto_recalibrate_probe_interval(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.auto_recalibrate_probe_interval'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.auto_recalibrate_probe_interval.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_move_speed.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_datapoints.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_mod_stop_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_greater_than = 1
        is_less_than = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_mod_stop_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeFwd_mod_stop_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.fwd_mod_stop_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_stop_mode.enum', list(new_val))


class RootLuSpecInstanceAttributePhase_bwd_mod_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_bwd_mod_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_mod_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_mod_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_mod_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_mod_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_bwd_mod_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_mod_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_bwd_mod_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_bwd_mod_rate.value', float(new_val))


class RootLuSpecInstanceAttributePhase_data_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_data_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_data_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_data_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_data_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_data_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_data_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_data_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_data_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_data_group_id.value', float(new_val))


class RootLuSpecInstanceAttributePhase_sample_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_sample_mask'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_sample_mask.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_sample_mask.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_sample_mask.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_sample_mask.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_sample_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_sample_mask.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_sample_mask.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_sample_mask.value', float(new_val))


class RootLuSpecInstanceAttributeRepetition_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.repetition_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.repetition_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.repetition_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.repetition_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.repetition_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.repetition_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.repetition_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.repetition_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.repetition_count.value', float(new_val))


class RootLuSpecInstanceAttributeFeedback_active(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.feedback_active'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.feedback_active.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.feedback_active.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.feedback_active.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.feedback_active.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.feedback_active.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.feedback_active.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.feedback_active.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.feedback_active.value', float(new_val))


class RootLuSpecInstanceAttributeXy_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.xy_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.xy_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.xy_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.xy_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.xy_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.xy_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.xy_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.xy_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.xy_move_speed.value', float(new_val))


class RootLuSpecInstanceAttributeSpec_map_configuration_blob_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.spec_map_configuration_blob_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.spec_map_configuration_blob_vec.vector', list(new_val))


class RootLuSpecInstanceAttributeStart_offset_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.start_offset_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.start_offset_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.start_offset_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset_move_speed.value', float(new_val))


class RootLuSpecInstanceAttributePhase_fwd_mod_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_fwd_mod_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_mod_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_mod_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_mod_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_mod_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_fwd_mod_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_mod_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_mod_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_mod_rate.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_mod_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        stop_by_value = 1
        fixed_length = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_mod_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeBwd_mod_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.bwd_mod_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.bwd_mod_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.bwd_mod_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_mode.enum', list(new_val))


class RootLuSpecInstanceAttributeDeflection_force_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.deflection_force_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.deflection_force_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.deflection_force_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.deflection_force_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.deflection_force_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.deflection_force_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.deflection_force_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.deflection_force_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.deflection_force_offset.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_mod_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_mod_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_mod_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_mod_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_mod_time.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_mod_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        stop_by_value = 1
        fixed_length = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_mod_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeFwd_mod_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.fwd_mod_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.fwd_mod_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.fwd_mod_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_mode.enum', list(new_val))


class RootLuSpecInstanceAttributeRepetition_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        position = 1
        list = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.repetition_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeRepetition_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.repetition_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.repetition_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.repetition_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.repetition_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.repetition_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.repetition_mode.enum', list(new_val))


class RootLuSpecInstanceAttributeFwd_pause_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_pause_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_pause_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_datapoints.value', float(new_val))


class RootLuSpecInstanceAttributePhase_fwd_pause_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.phase_fwd_pause_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_pause_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_pause_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_pause_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_pause_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.phase_fwd_pause_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_pause_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.phase_fwd_pause_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.phase_fwd_pause_rate.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_pause_datapoints(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_pause_datapoints'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_datapoints.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_datapoints.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_datapoints.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_datapoints.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_pause_datapoints.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_datapoints.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_datapoints.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_datapoints.value', float(new_val))


class RootLuSpecInstanceAttributeStart_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.start_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.start_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.start_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.start_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.start_offset.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_pause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_time.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.bwd_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.bwd_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.bwd_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.bwd_move_speed.value', float(new_val))


class RootLuSpecInstanceAttributeCurrent_repetition(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.current_repetition'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.current_repetition.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.current_repetition.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.current_repetition.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.current_repetition.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.current_repetition.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.current_repetition.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.current_repetition.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.current_repetition.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_mod_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_mod_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_mod_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_mod_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_mod_time.value', float(new_val))


class RootLuSpecInstanceAttributeFwd_pause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.fwd_pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.fwd_pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.fwd_pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.fwd_pause_time.value', float(new_val))


class RootLuSpecInstanceAttributeBwd_pause_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_off = 0
        z_on = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.bwd_pause_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSpecInstanceAttributeBwd_pause_mode.ValueEnum(self._context.get('root.lu.spec.instance.attribute.bwd_pause_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.spec.instance.attribute.bwd_pause_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.bwd_pause_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.bwd_pause_mode.enum', list(new_val))


class RootLuSpecInstanceAttributePoint_coords_blob_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.point_coords_blob_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.point_coords_blob_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.point_coords_blob_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.point_coords_blob_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.point_coords_blob_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.point_coords_blob_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.point_coords_blob_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.spec.instance.attribute.point_coords_blob_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.spec.instance.attribute.point_coords_blob_vec.vector', list(new_val))


class RootLuSpecInstanceAttributeMod_rel_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.mod_rel_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.mod_rel_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.mod_rel_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.mod_rel_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.mod_rel_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.mod_rel_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.mod_rel_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.mod_rel_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.mod_rel_value.value', float(new_val))


class RootLuSpecInstanceAttributeSpec_map_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute.spec_map_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.spec_map_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.spec_map_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.spec_map_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.spec_map_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.spec.instance.attribute.spec_map_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.spec.instance.attribute.spec_map_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.spec.instance.attribute.spec_map_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.spec.instance.attribute.spec_map_mode.value', float(new_val))


class RootLuSpecInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance.attribute'
        self.spec_map_mode = RootLuSpecInstanceAttributeSpec_map_mode(self._context)
        self.mod_rel_value = RootLuSpecInstanceAttributeMod_rel_value(self._context)
        self.point_coords_blob_vec = RootLuSpecInstanceAttributePoint_coords_blob_vec(self._context)
        self.bwd_pause_mode = RootLuSpecInstanceAttributeBwd_pause_mode(self._context)
        self.fwd_pause_time = RootLuSpecInstanceAttributeFwd_pause_time(self._context)
        self.fwd_mod_time = RootLuSpecInstanceAttributeFwd_mod_time(self._context)
        self.current_repetition = RootLuSpecInstanceAttributeCurrent_repetition(self._context)
        self.bwd_move_speed = RootLuSpecInstanceAttributeBwd_move_speed(self._context)
        self.bwd_pause_time = RootLuSpecInstanceAttributeBwd_pause_time(self._context)
        self.start_offset = RootLuSpecInstanceAttributeStart_offset(self._context)
        self.bwd_pause_datapoints = RootLuSpecInstanceAttributeBwd_pause_datapoints(self._context)
        self.phase_fwd_pause_rate = RootLuSpecInstanceAttributePhase_fwd_pause_rate(self._context)
        self.fwd_pause_datapoints = RootLuSpecInstanceAttributeFwd_pause_datapoints(self._context)
        self.repetition_mode = RootLuSpecInstanceAttributeRepetition_mode(self._context)
        self.fwd_mod_mode = RootLuSpecInstanceAttributeFwd_mod_mode(self._context)
        self.bwd_mod_time = RootLuSpecInstanceAttributeBwd_mod_time(self._context)
        self.deflection_force_offset = RootLuSpecInstanceAttributeDeflection_force_offset(self._context)
        self.bwd_mod_mode = RootLuSpecInstanceAttributeBwd_mod_mode(self._context)
        self.phase_fwd_mod_rate = RootLuSpecInstanceAttributePhase_fwd_mod_rate(self._context)
        self.start_offset_move_speed = RootLuSpecInstanceAttributeStart_offset_move_speed(self._context)
        self.spec_map_configuration_blob_vec = RootLuSpecInstanceAttributeSpec_map_configuration_blob_vec(self._context)
        self.xy_move_speed = RootLuSpecInstanceAttributeXy_move_speed(self._context)
        self.feedback_active = RootLuSpecInstanceAttributeFeedback_active(self._context)
        self.repetition_count = RootLuSpecInstanceAttributeRepetition_count(self._context)
        self.phase_sample_mask = RootLuSpecInstanceAttributePhase_sample_mask(self._context)
        self.phase_data_group_id = RootLuSpecInstanceAttributePhase_data_group_id(self._context)
        self.phase_bwd_mod_rate = RootLuSpecInstanceAttributePhase_bwd_mod_rate(self._context)
        self.fwd_mod_stop_mode = RootLuSpecInstanceAttributeFwd_mod_stop_mode(self._context)
        self.bwd_datapoints = RootLuSpecInstanceAttributeBwd_datapoints(self._context)
        self.fwd_move_speed = RootLuSpecInstanceAttributeFwd_move_speed(self._context)
        self.auto_recalibrate_probe_interval = RootLuSpecInstanceAttributeAuto_recalibrate_probe_interval(self._context)
        self.bwd_mod_stop_mode = RootLuSpecInstanceAttributeBwd_mod_stop_mode(self._context)
        self.fwd_datapoints = RootLuSpecInstanceAttributeFwd_datapoints(self._context)
        self.modulation_output = RootLuSpecInstanceAttributeModulation_output(self._context)
        self.fwd_pause_mode = RootLuSpecInstanceAttributeFwd_pause_mode(self._context)
        self.fwd_mod_stop_value = RootLuSpecInstanceAttributeFwd_mod_stop_value(self._context)
        self.fwd_mod_range = RootLuSpecInstanceAttributeFwd_mod_range(self._context)
        self.phase_bwd_pause_rate = RootLuSpecInstanceAttributePhase_bwd_pause_rate(self._context)
        self.spec_end_mode = RootLuSpecInstanceAttributeSpec_end_mode(self._context)
        self.bwd_mod_stop_value = RootLuSpecInstanceAttributeBwd_mod_stop_value(self._context)
        self.bwd_mod_range = RootLuSpecInstanceAttributeBwd_mod_range(self._context)


class RootLuSpecInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec.instance'
        self.attribute = RootLuSpecInstanceAttribute(self._context)
        self.trigger = RootLuSpecInstanceTrigger(self._context)
        self.busy = RootLuSpecInstanceBusy(self._context)


class RootLuSpec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.spec'
        self.instance = RootLuSpecInstance(self._context)


class RootLuAnalog_hi_res_inUser3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.busy'


class RootLuAnalog_hi_res_inUser3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.trigger'


class RootLuAnalog_hi_res_inUser3AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.input_gain'


class RootLuAnalog_hi_res_inUser3AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inUser3AttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser3AttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inUser3AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser3AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inUser3AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser3AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser3AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser3AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inUser3AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser3AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser3AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inUser3AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user3.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user3.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inUser3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inUser3AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inUser3AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inUser3AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inUser3AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inUser3AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inUser3AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inUser3AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inUser3AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inUser3AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inUser3AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inUser3AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inUser3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user3'
        self.attribute = RootLuAnalog_hi_res_inUser3Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inUser3Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_inUser3Busy(self._context)


class RootLuAnalog_hi_res_inUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.busy'


class RootLuAnalog_hi_res_inUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.trigger'


class RootLuAnalog_hi_res_inUser1AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.input_gain'


class RootLuAnalog_hi_res_inUser1AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inUser1AttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser1AttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inUser1AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser1AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inUser1AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser1AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser1AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser1AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inUser1AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser1AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser1AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inUser1AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user1.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user1.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inUser1AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inUser1AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inUser1AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inUser1AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inUser1AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inUser1AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inUser1AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inUser1AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inUser1AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inUser1AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inUser1AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user1'
        self.attribute = RootLuAnalog_hi_res_inUser1Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inUser1Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_inUser1Busy(self._context)


class RootLuAnalog_hi_res_inTip_currentBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.busy'


class RootLuAnalog_hi_res_inTip_currentTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.trigger'


class RootLuAnalog_hi_res_inTip_currentAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.input_gain'


class RootLuAnalog_hi_res_inTip_currentAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inTip_currentAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inTip_currentAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inTip_currentAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inTip_currentAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.tip_current.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inTip_currentAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inTip_currentAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inTip_currentAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inTip_currentAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inTip_currentAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inTip_currentAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inTip_currentAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inTip_currentAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inTip_currentAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inTip_currentAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inTip_currentAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inTip_currentAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inTip_current(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.tip_current'
        self.attribute = RootLuAnalog_hi_res_inTip_currentAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inTip_currentTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inTip_currentBusy(self._context)


class RootLuAnalog_hi_res_inDetector_sumBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.busy'


class RootLuAnalog_hi_res_inDetector_sumTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.trigger'


class RootLuAnalog_hi_res_inDetector_sumAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.input_gain'


class RootLuAnalog_hi_res_inDetector_sumAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDetector_sumAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDetector_sumAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDetector_sumAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.detector_sum.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inDetector_sumAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inDetector_sumAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inDetector_sumAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inDetector_sumAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inDetector_sumAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inDetector_sumAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inDetector_sumAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inDetector_sumAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inDetector_sumAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inDetector_sumAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inDetector_sumAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inDetector_sumAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inDetector_sum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.detector_sum'
        self.attribute = RootLuAnalog_hi_res_inDetector_sumAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inDetector_sumTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inDetector_sumBusy(self._context)


class RootLuAnalog_hi_res_inMain2AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.input_gain'


class RootLuAnalog_hi_res_inMain2AttributeCurrent_input_value(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.current_input_value'


class RootLuAnalog_hi_res_inMain2AttributeFilter_modeEnum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.filter_mode.enum'

    @property
    def no_filter(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.filter_mode.enum.no_filter'))

    @no_filter.setter
    def no_filter(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.filter_mode.enum.no_filter', int(new_val))

    @property
    def low_pass_filter(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.filter_mode.enum.low_pass_filter'))

    @low_pass_filter.setter
    def low_pass_filter(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.filter_mode.enum.low_pass_filter', int(new_val))


class RootLuAnalog_hi_res_inMain2AttributeFilter_mode(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.filter_mode'
        self.enum = RootLuAnalog_hi_res_inMain2AttributeFilter_modeEnum(self._context)


class RootLuAnalog_hi_res_inMain2AttributeCalib_polarityEnum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.calib_polarity.enum'

    @property
    def positive(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.calib_polarity.enum.positive'))

    @positive.setter
    def positive(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.calib_polarity.enum.positive', int(new_val))

    @property
    def negative(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.calib_polarity.enum.negative'))

    @negative.setter
    def negative(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.calib_polarity.enum.negative', int(new_val))


class RootLuAnalog_hi_res_inMain2AttributeCalib_polarity(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.calib_polarity'
        self.enum = RootLuAnalog_hi_res_inMain2AttributeCalib_polarityEnum(self._context)


class RootLuAnalog_hi_res_inMain2AttributeFilter_coeff_vec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.filter_coeff_vec'


class RootLuAnalog_hi_res_inMain2AttributeCalib_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.calib_offset'


class RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_idEnum(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum'

    @property
    def self(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.self'))

    @self.setter
    def self(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.self', int(new_val))

    @property
    def position_z(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_z'))

    @position_z.setter
    def position_z(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_z', int(new_val))

    @property
    def position_x(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_x'))

    @position_x.setter
    def position_x(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_x', int(new_val))

    @property
    def position_y(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_y'))

    @position_y.setter
    def position_y(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id.enum.position_y', int(new_val))


class RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_id(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_id'
        self.enum = RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_idEnum(self._context)


class RootLuAnalog_hi_res_inMain2AttributeInput_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.input_offset'


class RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.cross_coupling_axis_coefficient_vec'


class RootLuAnalog_hi_res_inMain2AttributeFilter_number(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.filter_number'


class RootLuAnalog_hi_res_inMain2AttributeCalib_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute.calib_gain'


class RootLuAnalog_hi_res_inMain2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inMain2AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inMain2AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inMain2AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inMain2AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inMain2AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inMain2AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inMain2AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inMain2AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inMain2AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inMain2AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inMain2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2.trigger'


class RootLuAnalog_hi_res_inMain2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.main2'
        self.trigger = RootLuAnalog_hi_res_inMain2Trigger(self._context)
        self.attribute = RootLuAnalog_hi_res_inMain2Attribute(self._context)


class RootLuAnalog_hi_res_inLateralBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.busy'


class RootLuAnalog_hi_res_inLateralTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.trigger'


class RootLuAnalog_hi_res_inLateralAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.input_gain'


class RootLuAnalog_hi_res_inLateralAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inLateralAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inLateralAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inLateralAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inLateralAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inLateralAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inLateralAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inLateralAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inLateralAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inLateralAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inLateralAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inLateralAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inLateralAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.lateral.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inLateralAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inLateralAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inLateralAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inLateralAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inLateralAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inLateralAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inLateralAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inLateralAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inLateralAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inLateralAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inLateralAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inLateralAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inLateral(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.lateral'
        self.attribute = RootLuAnalog_hi_res_inLateralAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inLateralTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inLateralBusy(self._context)


class RootLuAnalog_hi_res_inUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.busy'


class RootLuAnalog_hi_res_inUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.trigger'


class RootLuAnalog_hi_res_inUser2AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.input_gain'


class RootLuAnalog_hi_res_inUser2AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inUser2AttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser2AttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inUser2AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser2AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inUser2AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser2AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser2AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser2AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inUser2AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser2AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser2AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inUser2AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user2.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user2.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inUser2AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inUser2AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inUser2AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inUser2AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inUser2AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inUser2AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inUser2AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inUser2AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inUser2AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inUser2AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inUser2AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user2'
        self.attribute = RootLuAnalog_hi_res_inUser2Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inUser2Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_inUser2Busy(self._context)


class RootLuAnalog_hi_res_inPosition_zBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.busy'


class RootLuAnalog_hi_res_inPosition_zTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.trigger'


class RootLuAnalog_hi_res_inPosition_zAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.input_gain'


class RootLuAnalog_hi_res_inPosition_zAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_zAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_zAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_zAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_zAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_z.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_zAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inPosition_zAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inPosition_zAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inPosition_zAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inPosition_zAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inPosition_zAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inPosition_zAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inPosition_zAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inPosition_zAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inPosition_zAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inPosition_zAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inPosition_zAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inPosition_z(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_z'
        self.attribute = RootLuAnalog_hi_res_inPosition_zAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inPosition_zTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inPosition_zBusy(self._context)


class RootLuAnalog_hi_res_inPosition_yBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.busy'


class RootLuAnalog_hi_res_inPosition_yTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.trigger'


class RootLuAnalog_hi_res_inPosition_yAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.input_gain'


class RootLuAnalog_hi_res_inPosition_yAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_yAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_yAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_yAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_yAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_y.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_yAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inPosition_yAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inPosition_yAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inPosition_yAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inPosition_yAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inPosition_yAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inPosition_yAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inPosition_yAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inPosition_yAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inPosition_yAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inPosition_yAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inPosition_yAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inPosition_y(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_y'
        self.attribute = RootLuAnalog_hi_res_inPosition_yAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inPosition_yTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inPosition_yBusy(self._context)


class RootLuAnalog_hi_res_inPosition_xBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.busy'


class RootLuAnalog_hi_res_inPosition_xTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.trigger'


class RootLuAnalog_hi_res_inPosition_xAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.input_gain'


class RootLuAnalog_hi_res_inPosition_xAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_xAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_xAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inPosition_xAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_xAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.position_x.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inPosition_xAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inPosition_xAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inPosition_xAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inPosition_xAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inPosition_xAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inPosition_xAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inPosition_xAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inPosition_xAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inPosition_xAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inPosition_xAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inPosition_xAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inPosition_xAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inPosition_x(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.position_x'
        self.attribute = RootLuAnalog_hi_res_inPosition_xAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inPosition_xTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inPosition_xBusy(self._context)


class RootLuAnalog_hi_res_inUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.busy'


class RootLuAnalog_hi_res_inUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.trigger'


class RootLuAnalog_hi_res_inUser4AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.input_gain'


class RootLuAnalog_hi_res_inUser4AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inUser4AttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser4AttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inUser4AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser4AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inUser4AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser4AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser4AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inUser4AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inUser4AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inUser4AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inUser4AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inUser4AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.user4.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.user4.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inUser4AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inUser4AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inUser4AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inUser4AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inUser4AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inUser4AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inUser4AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inUser4AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inUser4AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inUser4AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inUser4AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.user4'
        self.attribute = RootLuAnalog_hi_res_inUser4Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inUser4Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_inUser4Busy(self._context)


class RootLuAnalog_hi_res_inDeflectionBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.busy'


class RootLuAnalog_hi_res_inDeflectionTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.trigger'


class RootLuAnalog_hi_res_inDeflectionAttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.input_gain'


class RootLuAnalog_hi_res_inDeflectionAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDeflectionAttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDeflectionAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inDeflectionAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inDeflectionAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.deflection.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inDeflectionAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inDeflectionAttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inDeflectionAttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inDeflectionAttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inDeflectionAttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inDeflectionAttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inDeflectionAttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inDeflectionAttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inDeflectionAttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inDeflectionAttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inDeflectionAttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inDeflectionAttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inDeflection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.deflection'
        self.attribute = RootLuAnalog_hi_res_inDeflectionAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inDeflectionTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_inDeflectionBusy(self._context)


class RootLuAnalog_hi_res_inIn6Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.busy'


class RootLuAnalog_hi_res_inIn6Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.trigger'


class RootLuAnalog_hi_res_inIn6AttributeInput_gain(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.input_gain'


class RootLuAnalog_hi_res_inIn6AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_hi_res_inIn6AttributeFilter_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_filter = 0
        low_pass_filter = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.filter_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inIn6AttributeFilter_mode.ValueEnum(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_mode.enum', list(new_val))


class RootLuAnalog_hi_res_inIn6AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inIn6AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_inIn6AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inIn6AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_inIn6AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_inIn6AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_hi_res_inIn6AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.input_offset.value', float(new_val))


class RootLuAnalog_hi_res_inIn6AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_hi_res_inIn6AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_inIn6AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_in.in6.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_in.in6.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_inIn6Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6.attribute'
        self.calib_gain = RootLuAnalog_hi_res_inIn6AttributeCalib_gain(self._context)
        self.filter_number = RootLuAnalog_hi_res_inIn6AttributeFilter_number(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_hi_res_inIn6AttributeCross_coupling_axis_coefficient_vec(self._context)
        self.input_offset = RootLuAnalog_hi_res_inIn6AttributeInput_offset(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_hi_res_inIn6AttributeCross_coupling_axis_id(self._context)
        self.calib_offset = RootLuAnalog_hi_res_inIn6AttributeCalib_offset(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_inIn6AttributeFilter_coeff_vec(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_inIn6AttributeCalib_polarity(self._context)
        self.filter_mode = RootLuAnalog_hi_res_inIn6AttributeFilter_mode(self._context)
        self.current_input_value = RootLuAnalog_hi_res_inIn6AttributeCurrent_input_value(self._context)
        self.input_gain = RootLuAnalog_hi_res_inIn6AttributeInput_gain(self._context)


class RootLuAnalog_hi_res_inIn6(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in.in6'
        self.attribute = RootLuAnalog_hi_res_inIn6Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_inIn6Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_inIn6Busy(self._context)


class RootLuAnalog_hi_res_in(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_in'
        self.in6 = RootLuAnalog_hi_res_inIn6(self._context)
        self.deflection = RootLuAnalog_hi_res_inDeflection(self._context)
        self.user4 = RootLuAnalog_hi_res_inUser4(self._context)
        self.position_x = RootLuAnalog_hi_res_inPosition_x(self._context)
        self.position_y = RootLuAnalog_hi_res_inPosition_y(self._context)
        self.position_z = RootLuAnalog_hi_res_inPosition_z(self._context)
        self.user2 = RootLuAnalog_hi_res_inUser2(self._context)
        self.lateral = RootLuAnalog_hi_res_inLateral(self._context)
        self.main2 = RootLuAnalog_hi_res_inMain2(self._context)
        self.detector_sum = RootLuAnalog_hi_res_inDetector_sum(self._context)
        self.tip_current = RootLuAnalog_hi_res_inTip_current(self._context)
        self.user1 = RootLuAnalog_hi_res_inUser1(self._context)
        self.user3 = RootLuAnalog_hi_res_inUser3(self._context)


class RootLuOrtInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.busy'

    @property
    def is_averaging(self) -> bool:
        return bool(self._context.call('root.lu.ort.instance.busy.is_averaging'))


class RootLuOrtInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.trigger'

    def apply_samples_values(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.apply_samples_values')

    def apply_samples_per_period(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.apply_samples_per_period')

    def update_free_wave(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.update_free_wave')

    def average_stop(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.average_stop')

    def process_averaged_samples(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.process_averaged_samples')

    def average_start(self) -> None:
        return self._context.call('root.lu.ort.instance.trigger.average_start')


class RootLuOrtInstanceAttributeBaseline_window_begin(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.baseline_window_begin'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_begin.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_begin.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_begin.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_begin.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.baseline_window_begin.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_begin.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_begin.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_begin.value', float(new_val))


class RootLuOrtInstanceAttributeBaseline_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.baseline_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.baseline_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.baseline_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_frequency.value', float(new_val))


class RootLuOrtInstanceAttributeBaseline_controller_state(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.baseline_controller_state'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuOrtInstanceAttributeBaseline_controller_state.ValueEnum(self._context.get('root.lu.ort.instance.attribute.baseline_controller_state.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ort.instance.attribute.baseline_controller_state.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ort.instance.attribute.baseline_controller_state.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ort.instance.attribute.baseline_controller_state.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ort.instance.attribute.baseline_controller_state.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ort.instance.attribute.baseline_controller_state.enum', list(new_val))


class RootLuOrtInstanceAttributeCantilever_samples_per_period(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.cantilever_samples_per_period'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.cantilever_samples_per_period.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.cantilever_samples_per_period.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.cantilever_samples_per_period.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.cantilever_samples_per_period.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.cantilever_samples_per_period.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.cantilever_samples_per_period.unit', str(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ort.instance.attribute.cantilever_samples_per_period.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ort.instance.attribute.cantilever_samples_per_period.enum', list(new_val))

    @property
    def value(self) -> ValueEnum:
        return RootLuOrtInstanceAttributeCantilever_samples_per_period.ValueEnum(self._context.get('root.lu.ort.instance.attribute.cantilever_samples_per_period.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ort.instance.attribute.cantilever_samples_per_period.value_raw', new_val.value)


class RootLuOrtInstanceAttributeExcitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.excitation_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.excitation_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.excitation_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.excitation_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.excitation_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.excitation_amplitude.value', float(new_val))


class RootLuOrtInstanceAttributeAmplitude_reduction(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.amplitude_reduction'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.amplitude_reduction.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.amplitude_reduction.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.amplitude_reduction.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.amplitude_reduction.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.amplitude_reduction.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.amplitude_reduction.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.amplitude_reduction.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.amplitude_reduction.value', float(new_val))


class RootLuOrtInstanceAttributeSamples_per_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.samples_per_period'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.samples_per_period.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.samples_per_period.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.samples_per_period.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.samples_per_period.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.samples_per_period.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.samples_per_period.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.samples_per_period.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.samples_per_period.value', float(new_val))


class RootLuOrtInstanceAttributeBaseline_window_end(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.baseline_window_end'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_end.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_end.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_end.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_end.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.baseline_window_end.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_end.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_window_end.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_window_end.value', float(new_val))


class RootLuOrtInstanceAttributeFree_wave_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.free_wave_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.free_wave_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.free_wave_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.free_wave_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.free_wave_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.free_wave_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.free_wave_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.free_wave_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.free_wave_delay.value', float(new_val))


class RootLuOrtInstanceAttributeFree_wave_output_state(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.free_wave_output_state'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuOrtInstanceAttributeFree_wave_output_state.ValueEnum(self._context.get('root.lu.ort.instance.attribute.free_wave_output_state.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ort.instance.attribute.free_wave_output_state.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ort.instance.attribute.free_wave_output_state.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ort.instance.attribute.free_wave_output_state.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ort.instance.attribute.free_wave_output_state.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ort.instance.attribute.free_wave_output_state.enum', list(new_val))


class RootLuOrtInstanceAttributeInput_select(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fast_in_user = 2
        hi_res_in_deflection = 1
        fast_in_deflection = 0
        hi_res_in_user1 = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.input_select'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuOrtInstanceAttributeInput_select.ValueEnum(self._context.get('root.lu.ort.instance.attribute.input_select.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ort.instance.attribute.input_select.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ort.instance.attribute.input_select.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ort.instance.attribute.input_select.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ort.instance.attribute.input_select.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ort.instance.attribute.input_select.enum', list(new_val))


class RootLuOrtInstanceAttributeAverage_periods(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.average_periods'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.average_periods.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.average_periods.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.average_periods.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.average_periods.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.average_periods.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.average_periods.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.average_periods.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.average_periods.value', float(new_val))


class RootLuOrtInstanceAttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_value.value', float(new_val))


class RootLuOrtInstanceAttributeMin_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.min_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_position.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_position.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_position.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_position.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.min_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.min_position.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.min_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.min_position.value', float(new_val))


class RootLuOrtInstanceAttributeFeedback_amplitude_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.feedback_amplitude_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.feedback_amplitude_position.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.feedback_amplitude_position.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.feedback_amplitude_position.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.feedback_amplitude_position.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.feedback_amplitude_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.feedback_amplitude_position.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.feedback_amplitude_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.feedback_amplitude_position.value', float(new_val))


class RootLuOrtInstanceAttributeBaseline_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute.baseline_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ort.instance.attribute.baseline_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ort.instance.attribute.baseline_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ort.instance.attribute.baseline_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ort.instance.attribute.baseline_amplitude.value', float(new_val))


class RootLuOrtInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance.attribute'
        self.baseline_amplitude = RootLuOrtInstanceAttributeBaseline_amplitude(self._context)
        self.feedback_amplitude_position = RootLuOrtInstanceAttributeFeedback_amplitude_position(self._context)
        self.min_position = RootLuOrtInstanceAttributeMin_position(self._context)
        self.min_value = RootLuOrtInstanceAttributeMin_value(self._context)
        self.average_periods = RootLuOrtInstanceAttributeAverage_periods(self._context)
        self.input_select = RootLuOrtInstanceAttributeInput_select(self._context)
        self.free_wave_output_state = RootLuOrtInstanceAttributeFree_wave_output_state(self._context)
        self.free_wave_delay = RootLuOrtInstanceAttributeFree_wave_delay(self._context)
        self.baseline_window_end = RootLuOrtInstanceAttributeBaseline_window_end(self._context)
        self.samples_per_period = RootLuOrtInstanceAttributeSamples_per_period(self._context)
        self.amplitude_reduction = RootLuOrtInstanceAttributeAmplitude_reduction(self._context)
        self.excitation_amplitude = RootLuOrtInstanceAttributeExcitation_amplitude(self._context)
        self.cantilever_samples_per_period = RootLuOrtInstanceAttributeCantilever_samples_per_period(self._context)
        self.baseline_controller_state = RootLuOrtInstanceAttributeBaseline_controller_state(self._context)
        self.baseline_frequency = RootLuOrtInstanceAttributeBaseline_frequency(self._context)
        self.baseline_window_begin = RootLuOrtInstanceAttributeBaseline_window_begin(self._context)


class RootLuOrtInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort.instance'
        self.attribute = RootLuOrtInstanceAttribute(self._context)
        self.trigger = RootLuOrtInstanceTrigger(self._context)
        self.busy = RootLuOrtInstanceBusy(self._context)


class RootLuOrt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ort'
        self.instance = RootLuOrtInstance(self._context)


class RootLuRescanInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.busy'


class RootLuRescanInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.trigger'


class RootLuRescanInstanceAttributeLine_repetition_max_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.attribute.line_repetition_max_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max_count.value', float(new_val))


class RootLuRescanInstanceAttributeEnable(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.attribute.enable'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.enable.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.enable.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.enable.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.enable.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.rescan.instance.attribute.enable.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.rescan.instance.attribute.enable.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.enable.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.enable.value', float(new_val))


class RootLuRescanInstanceAttributeLine_repetition_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.attribute.line_repetition_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_max.value', float(new_val))


class RootLuRescanInstanceAttributeLine_repetition_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.attribute.line_repetition_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.rescan.instance.attribute.line_repetition_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.rescan.instance.attribute.line_repetition_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.rescan.instance.attribute.line_repetition_count.value', float(new_val))


class RootLuRescanInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance.attribute'
        self.line_repetition_count = RootLuRescanInstanceAttributeLine_repetition_count(self._context)
        self.line_repetition_max = RootLuRescanInstanceAttributeLine_repetition_max(self._context)
        self.enable = RootLuRescanInstanceAttributeEnable(self._context)
        self.line_repetition_max_count = RootLuRescanInstanceAttributeLine_repetition_max_count(self._context)


class RootLuRescanInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan.instance'
        self.attribute = RootLuRescanInstanceAttribute(self._context)
        self.trigger = RootLuRescanInstanceTrigger(self._context)
        self.busy = RootLuRescanInstanceBusy(self._context)


class RootLuRescan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.rescan'
        self.instance = RootLuRescanInstance(self._context)


class RootLuScanInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.busy'


class RootLuScanInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.trigger'

    def do_set_xy_sensor_data_acquisition(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.do_set_xy_sensor_data_acquisition')

    def start_move_to_start(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.start_move_to_start')

    def offset_xyz(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.offset_xyz')

    def start_do_frame(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.start_do_frame')

    def start_move_to_start_and_do_frame_quick(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.start_move_to_start_and_do_frame_quick')

    def start_move_to_start_and_do_frame(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.start_move_to_start_and_do_frame')

    def user_abort(self) -> None:
        return self._context.call('root.lu.scan.instance.trigger.user_abort')


class RootLuScanInstanceAttributeFast_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.fast_points'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_points.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_points.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_points.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_points.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.fast_points.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.fast_points.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_points.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_points.value', float(new_val))


class RootLuScanInstanceAttributeFirst_line_repetition(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.first_line_repetition'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.first_line_repetition.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.first_line_repetition.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.first_line_repetition.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.first_line_repetition.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.first_line_repetition.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.first_line_repetition.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.first_line_repetition.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.first_line_repetition.value', float(new_val))


class RootLuScanInstanceAttributeReadjust_lift_height(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.readjust_lift_height'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.readjust_lift_height.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.readjust_lift_height.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.readjust_lift_height.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.readjust_lift_height.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.readjust_lift_height.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.readjust_lift_height.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.readjust_lift_height.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.readjust_lift_height.value', float(new_val))


class RootLuScanInstanceAttributeXy_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.xy_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.xy_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.xy_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.xy_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.xy_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.xy_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.xy_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.xy_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.xy_move_speed.value', float(new_val))


class RootLuScanInstanceAttributeLine_z_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.line_z_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.line_z_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.line_z_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.line_z_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.line_z_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.line_z_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.line_z_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.line_z_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.line_z_offset.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_dynamic_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_enable_dark_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_enable_dark_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_dark_mode.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_enable_kpfm(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_enable_kpfm'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_enable_kpfm.value', float(new_val))


class RootLuScanInstanceAttributeContour_data_channel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.contour_data_channel'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_data_channel.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_data_channel.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_data_channel.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_data_channel.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.contour_data_channel.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.contour_data_channel.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_data_channel.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_data_channel.value', float(new_val))


class RootLuScanInstanceAttributeSlow_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.slow_points'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_points.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_points.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_points.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_points.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.slow_points.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.slow_points.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_points.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_points.value', float(new_val))


class RootLuScanInstanceAttributeOverscan_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.overscan_points'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.overscan_points.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.overscan_points.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.overscan_points.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.overscan_points.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.overscan_points.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.overscan_points.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.overscan_points.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.overscan_points.value', float(new_val))


class RootLuScanInstanceAttributeX_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.x_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_rotation.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_rotation.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_rotation.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_rotation.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.x_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.x_rotation.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_rotation.value', float(new_val))


class RootLuScanInstanceAttributeContour_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.contour_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.contour_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.contour_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.contour_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.contour_enabled.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_force_modulation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_force_modulation_amplitude_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_force_modulation_amplitude_enabled.value', float(new_val))


class RootLuScanInstanceAttributeSlow_increment(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.slow_increment'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_increment.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_increment.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_increment.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_increment.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.slow_increment.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.slow_increment.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_increment.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_increment.value', float(new_val))


class RootLuScanInstanceAttributeZ_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.z_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.z_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.z_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_move_speed.value', float(new_val))


class RootLuScanInstanceAttributeSlow_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.slow_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.slow_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.slow_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.slow_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.slow_range.value', float(new_val))


class RootLuScanInstanceAttributeZ_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.z_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_rotation.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_rotation.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_rotation.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_rotation.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.z_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.z_rotation.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_rotation.value', float(new_val))


class RootLuScanInstanceAttributeAuto_readjust_probe_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.auto_readjust_probe_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.auto_readjust_probe_enabled.value', float(new_val))


class RootLuScanInstanceAttributeX_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.x_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.x_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.x_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.x_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.x_offset.value', float(new_val))


class RootLuScanInstanceAttributeZ_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.z_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.z_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.z_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.z_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.z_offset.value', float(new_val))


class RootLuScanInstanceAttributeY_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.y_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.y_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.y_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_offset.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_dynamic_amplitude_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_dynamic_amplitude_enabled.value', float(new_val))


class RootLuScanInstanceAttributeLine_scanning(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        dual_scan = 1
        standard = 0
        snd_scan_only = 3
        interlaced = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.line_scanning'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeLine_scanning.ValueEnum(self._context.get('root.lu.scan.instance.attribute.line_scanning.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.line_scanning.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.line_scanning.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.line_scanning.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.line_scanning.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.line_scanning.enum', list(new_val))


class RootLuScanInstanceAttributeTime_per_line(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.time_per_line'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.time_per_line.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.time_per_line.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.time_per_line.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.time_per_line.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.time_per_line.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.time_per_line.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.time_per_line.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.time_per_line.value', float(new_val))


class RootLuScanInstanceAttributeFast_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.fast_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.fast_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.fast_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.fast_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.fast_range.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_snd_lock_in_excitation_amplitude_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude_enabled.value', float(new_val))


class RootLuScanInstanceAttributeBackward_fast_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.backward_fast_points'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.backward_fast_points.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.backward_fast_points.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.backward_fast_points.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.backward_fast_points.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.backward_fast_points.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.backward_fast_points.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.backward_fast_points.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.backward_fast_points.value', float(new_val))


class RootLuScanInstanceAttributeSnd_scan_snd_lock_in_excitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.snd_scan_snd_lock_in_excitation_amplitude.value', float(new_val))


class RootLuScanInstanceAttributeLinearization_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.linearization_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeLinearization_enable.ValueEnum(self._context.get('root.lu.scan.instance.attribute.linearization_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.linearization_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.linearization_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.linearization_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.linearization_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.linearization_enable.enum', list(new_val))


class RootLuScanInstanceAttributeMove_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        lifted = 1
        controlled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.move_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeMove_mode.ValueEnum(self._context.get('root.lu.scan.instance.attribute.move_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.move_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.move_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.move_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.move_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.move_mode.enum', list(new_val))


class RootLuScanInstanceAttributeScan_direction_slow_axis(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        upward = 1
        downward = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.scan_direction_slow_axis'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeScan_direction_slow_axis.ValueEnum(self._context.get('root.lu.scan.instance.attribute.scan_direction_slow_axis.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.scan_direction_slow_axis.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.scan_direction_slow_axis.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.scan_direction_slow_axis.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.scan_direction_slow_axis.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.scan_direction_slow_axis.enum', list(new_val))


class RootLuScanInstanceAttributeSlow_axis_move_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        continuous = 2
        stepwise = 0
        serpentine = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.slow_axis_move_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeSlow_axis_move_mode.ValueEnum(self._context.get('root.lu.scan.instance.attribute.slow_axis_move_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.slow_axis_move_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.slow_axis_move_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.slow_axis_move_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.slow_axis_move_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.slow_axis_move_mode.enum', list(new_val))


class RootLuScanInstanceAttributeY_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.y_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_rotation.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_rotation.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_rotation.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_rotation.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scan.instance.attribute.y_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scan.instance.attribute.y_rotation.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scan.instance.attribute.y_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scan.instance.attribute.y_rotation.value', float(new_val))


class RootLuScanInstanceAttributeGenerator(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        linear_line = 0
        generic_frame = 2
        generic_frame_fast = 3
        generic_line = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute.generator'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanInstanceAttributeGenerator.ValueEnum(self._context.get('root.lu.scan.instance.attribute.generator.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scan.instance.attribute.generator.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scan.instance.attribute.generator.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scan.instance.attribute.generator.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scan.instance.attribute.generator.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scan.instance.attribute.generator.enum', list(new_val))


class RootLuScanInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance.attribute'
        self.generator = RootLuScanInstanceAttributeGenerator(self._context)
        self.y_rotation = RootLuScanInstanceAttributeY_rotation(self._context)
        self.slow_axis_move_mode = RootLuScanInstanceAttributeSlow_axis_move_mode(self._context)
        self.scan_direction_slow_axis = RootLuScanInstanceAttributeScan_direction_slow_axis(self._context)
        self.move_mode = RootLuScanInstanceAttributeMove_mode(self._context)
        self.linearization_enable = RootLuScanInstanceAttributeLinearization_enable(self._context)
        self.snd_scan_snd_lock_in_excitation_amplitude = RootLuScanInstanceAttributeSnd_scan_snd_lock_in_excitation_amplitude(self._context)
        self.backward_fast_points = RootLuScanInstanceAttributeBackward_fast_points(self._context)
        self.snd_scan_snd_lock_in_excitation_amplitude_enabled = RootLuScanInstanceAttributeSnd_scan_snd_lock_in_excitation_amplitude_enabled(self._context)
        self.fast_range = RootLuScanInstanceAttributeFast_range(self._context)
        self.time_per_line = RootLuScanInstanceAttributeTime_per_line(self._context)
        self.line_scanning = RootLuScanInstanceAttributeLine_scanning(self._context)
        self.snd_scan_dynamic_amplitude_enabled = RootLuScanInstanceAttributeSnd_scan_dynamic_amplitude_enabled(self._context)
        self.y_offset = RootLuScanInstanceAttributeY_offset(self._context)
        self.z_offset = RootLuScanInstanceAttributeZ_offset(self._context)
        self.x_offset = RootLuScanInstanceAttributeX_offset(self._context)
        self.auto_readjust_probe_enabled = RootLuScanInstanceAttributeAuto_readjust_probe_enabled(self._context)
        self.z_rotation = RootLuScanInstanceAttributeZ_rotation(self._context)
        self.slow_range = RootLuScanInstanceAttributeSlow_range(self._context)
        self.z_move_speed = RootLuScanInstanceAttributeZ_move_speed(self._context)
        self.slow_increment = RootLuScanInstanceAttributeSlow_increment(self._context)
        self.snd_scan_force_modulation_amplitude_enabled = RootLuScanInstanceAttributeSnd_scan_force_modulation_amplitude_enabled(self._context)
        self.snd_scan_force_modulation_amplitude = RootLuScanInstanceAttributeSnd_scan_force_modulation_amplitude(self._context)
        self.contour_enabled = RootLuScanInstanceAttributeContour_enabled(self._context)
        self.x_rotation = RootLuScanInstanceAttributeX_rotation(self._context)
        self.overscan_points = RootLuScanInstanceAttributeOverscan_points(self._context)
        self.slow_points = RootLuScanInstanceAttributeSlow_points(self._context)
        self.contour_data_channel = RootLuScanInstanceAttributeContour_data_channel(self._context)
        self.snd_scan_enable_kpfm = RootLuScanInstanceAttributeSnd_scan_enable_kpfm(self._context)
        self.snd_scan_enable_dark_mode = RootLuScanInstanceAttributeSnd_scan_enable_dark_mode(self._context)
        self.snd_scan_dynamic_amplitude = RootLuScanInstanceAttributeSnd_scan_dynamic_amplitude(self._context)
        self.line_z_offset = RootLuScanInstanceAttributeLine_z_offset(self._context)
        self.xy_move_speed = RootLuScanInstanceAttributeXy_move_speed(self._context)
        self.readjust_lift_height = RootLuScanInstanceAttributeReadjust_lift_height(self._context)
        self.first_line_repetition = RootLuScanInstanceAttributeFirst_line_repetition(self._context)
        self.fast_points = RootLuScanInstanceAttributeFast_points(self._context)


class RootLuScanInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan.instance'
        self.attribute = RootLuScanInstanceAttribute(self._context)
        self.trigger = RootLuScanInstanceTrigger(self._context)
        self.busy = RootLuScanInstanceBusy(self._context)


class RootLuScan(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scan'
        self.instance = RootLuScanInstance(self._context)


class RootLuScanheadInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.busy'


class RootLuScanheadInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.trigger'

    def enable_pte_laser(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.enable_pte_laser')

    def apply_tilt_mode(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.apply_tilt_mode')

    def disable_piezo_electric_excitation(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.disable_piezo_electric_excitation')

    def disable_readout_laser(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.disable_readout_laser')

    def enable_readout_laser(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.enable_readout_laser')

    def disable_electro_thermal_excitation(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.disable_electro_thermal_excitation')

    def enable_electro_thermal_excitation(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.enable_electro_thermal_excitation')

    def enable_piezo_electric_excitation(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.enable_piezo_electric_excitation')

    def disable_pte_laser(self) -> None:
        return self._context.call('root.lu.scanhead.instance.trigger.disable_pte_laser')


class RootLuScanheadInstanceAttributePte_laser_setpoint(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.pte_laser_setpoint'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_setpoint.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_setpoint.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_setpoint.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_setpoint.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_setpoint.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_setpoint.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_setpoint.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_setpoint.value', float(new_val))


class RootLuScanheadInstanceAttributePte_laser_power_monitor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.pte_laser_power_monitor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.pte_laser_power_monitor.value', float(new_val))


class RootLuScanheadInstanceAttributeHas_z_sensor(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no = 0
        yes = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.has_z_sensor'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanheadInstanceAttributeHas_z_sensor.ValueEnum(self._context.get('root.lu.scanhead.instance.attribute.has_z_sensor.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scanhead.instance.attribute.has_z_sensor.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scanhead.instance.attribute.has_z_sensor.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scanhead.instance.attribute.has_z_sensor.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scanhead.instance.attribute.has_z_sensor.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scanhead.instance.attribute.has_z_sensor.enum', list(new_val))


class RootLuScanheadInstanceAttributeTilt_angle_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.tilt_angle_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_y.value', float(new_val))


class RootLuScanheadInstanceAttributeTilt_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        measured = 1
        override = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.tilt_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanheadInstanceAttributeTilt_mode.ValueEnum(self._context.get('root.lu.scanhead.instance.attribute.tilt_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scanhead.instance.attribute.tilt_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scanhead.instance.attribute.tilt_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_mode.enum', list(new_val))


class RootLuScanheadInstanceAttributeReadout_laser_power_monitor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.readout_laser_power_monitor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_power_monitor.value', float(new_val))


class RootLuScanheadInstanceAttributeReadout_laser_setpoint(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.readout_laser_setpoint'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_setpoint.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_setpoint.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_setpoint.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_setpoint.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_setpoint.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_setpoint.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.readout_laser_setpoint.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.readout_laser_setpoint.value', float(new_val))


class RootLuScanheadInstanceAttributeType(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        semafm = 16
        arac = 17
        dummy3 = 3
        nanite_afm = 12
        p6_mount = 21
        not_connected = 0
        e_afm = 9
        dummy10 = 10
        afsem = 13
        unknown = 1
        e_stm = 2
        core_afm = 19
        lens_afm = 15
        dummy4 = 4
        dummy6 = 6
        dummy5 = 5
        dummy8 = 8
        dummy7 = 7
        cytomass = 20
        dummy11 = 11
        flex_afm = 14
        p6 = 18

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.type'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanheadInstanceAttributeType.ValueEnum(self._context.get('root.lu.scanhead.instance.attribute.type.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scanhead.instance.attribute.type.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scanhead.instance.attribute.type.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scanhead.instance.attribute.type.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scanhead.instance.attribute.type.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scanhead.instance.attribute.type.enum', list(new_val))


class RootLuScanheadInstanceAttributeTilt_angle_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.tilt_angle_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.scanhead.instance.attribute.tilt_angle_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.scanhead.instance.attribute.tilt_angle_x.value', float(new_val))


class RootLuScanheadInstanceAttributeFast_in2_channel(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        addon_in = 1
        friction_channel = 0
        pte_monitor = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.fast_in2_channel'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanheadInstanceAttributeFast_in2_channel.ValueEnum(self._context.get('root.lu.scanhead.instance.attribute.fast_in2_channel.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scanhead.instance.attribute.fast_in2_channel.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scanhead.instance.attribute.fast_in2_channel.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scanhead.instance.attribute.fast_in2_channel.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scanhead.instance.attribute.fast_in2_channel.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scanhead.instance.attribute.fast_in2_channel.enum', list(new_val))


class RootLuScanheadInstanceAttributeHas_xy_sensor(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no = 0
        yes = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute.has_xy_sensor'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuScanheadInstanceAttributeHas_xy_sensor.ValueEnum(self._context.get('root.lu.scanhead.instance.attribute.has_xy_sensor.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.scanhead.instance.attribute.has_xy_sensor.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.scanhead.instance.attribute.has_xy_sensor.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.scanhead.instance.attribute.has_xy_sensor.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.scanhead.instance.attribute.has_xy_sensor.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.scanhead.instance.attribute.has_xy_sensor.enum', list(new_val))


class RootLuScanheadInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance.attribute'
        self.has_xy_sensor = RootLuScanheadInstanceAttributeHas_xy_sensor(self._context)
        self.fast_in2_channel = RootLuScanheadInstanceAttributeFast_in2_channel(self._context)
        self.tilt_angle_x = RootLuScanheadInstanceAttributeTilt_angle_x(self._context)
        self.type = RootLuScanheadInstanceAttributeType(self._context)
        self.readout_laser_setpoint = RootLuScanheadInstanceAttributeReadout_laser_setpoint(self._context)
        self.readout_laser_power_monitor = RootLuScanheadInstanceAttributeReadout_laser_power_monitor(self._context)
        self.tilt_mode = RootLuScanheadInstanceAttributeTilt_mode(self._context)
        self.tilt_angle_y = RootLuScanheadInstanceAttributeTilt_angle_y(self._context)
        self.has_z_sensor = RootLuScanheadInstanceAttributeHas_z_sensor(self._context)
        self.pte_laser_power_monitor = RootLuScanheadInstanceAttributePte_laser_power_monitor(self._context)
        self.pte_laser_setpoint = RootLuScanheadInstanceAttributePte_laser_setpoint(self._context)


class RootLuScanheadInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead.instance'
        self.attribute = RootLuScanheadInstanceAttribute(self._context)
        self.trigger = RootLuScanheadInstanceTrigger(self._context)
        self.busy = RootLuScanheadInstanceBusy(self._context)


class RootLuScanhead(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.scanhead'
        self.instance = RootLuScanheadInstance(self._context)


class RootLuSequencerInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.busy'

    @property
    def is_running(self) -> bool:
        return bool(self._context.call('root.lu.sequencer.instance.busy.is_running'))


class RootLuSequencerInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.sequencer.instance.trigger.start')

    def step(self) -> None:
        return self._context.call('root.lu.sequencer.instance.trigger.step')

    def abort(self) -> None:
        return self._context.call('root.lu.sequencer.instance.trigger.abort')


class RootLuSequencerInstanceAttributeInstruction_pointer(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.attribute.instruction_pointer'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.instruction_pointer.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.instruction_pointer.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.instruction_pointer.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.instruction_pointer.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sequencer.instance.attribute.instruction_pointer.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sequencer.instance.attribute.instruction_pointer.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.instruction_pointer.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.instruction_pointer.value', float(new_val))


class RootLuSequencerInstanceAttributeMemory_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.attribute.memory_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.memory_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.memory_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.memory_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.memory_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sequencer.instance.attribute.memory_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sequencer.instance.attribute.memory_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.sequencer.instance.attribute.memory_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.sequencer.instance.attribute.memory_vec.vector', list(new_val))


class RootLuSequencerInstanceAttributeStatus(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.attribute.status'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.status.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.status.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.status.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.status.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sequencer.instance.attribute.status.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sequencer.instance.attribute.status.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sequencer.instance.attribute.status.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sequencer.instance.attribute.status.value', float(new_val))


class RootLuSequencerInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance.attribute'
        self.status = RootLuSequencerInstanceAttributeStatus(self._context)
        self.memory_vec = RootLuSequencerInstanceAttributeMemory_vec(self._context)
        self.instruction_pointer = RootLuSequencerInstanceAttributeInstruction_pointer(self._context)


class RootLuSequencerInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer.instance'
        self.attribute = RootLuSequencerInstanceAttribute(self._context)
        self.trigger = RootLuSequencerInstanceTrigger(self._context)
        self.busy = RootLuSequencerInstanceBusy(self._context)


class RootLuSequencer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sequencer'
        self.instance = RootLuSequencerInstance(self._context)


class RootLuRamp_generatorVirtual0Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.virtual0.busy.is_moving'))


class RootLuRamp_generatorVirtual0Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual0.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual0.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual0.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual0.trigger.abort')


class RootLuRamp_generatorVirtual0AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual0AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual0AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual0AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.virtual0.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual0.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual0.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.status.enum', list(new_val))


class RootLuRamp_generatorVirtual0AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual0.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorVirtual0AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual0AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual0.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual0.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual0Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0.attribute'
        self.end_value_mode = RootLuRamp_generatorVirtual0AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorVirtual0AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorVirtual0AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorVirtual0AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorVirtual0AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorVirtual0AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorVirtual0AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorVirtual0AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorVirtual0AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorVirtual0AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorVirtual0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual0'
        self.attribute = RootLuRamp_generatorVirtual0Attribute(self._context)
        self.trigger = RootLuRamp_generatorVirtual0Trigger(self._context)
        self.busy = RootLuRamp_generatorVirtual0Busy(self._context)


class RootLuRamp_generatorUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.user1.busy.is_moving'))


class RootLuRamp_generatorUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.user1.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.user1.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.user1.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.user1.trigger.abort')


class RootLuRamp_generatorUser1AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorUser1AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser1AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user1.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user1.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user1.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorUser1AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser1AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.user1.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user1.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user1.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user1.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user1.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user1.attribute.status.enum', list(new_val))


class RootLuRamp_generatorUser1AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorUser1AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorUser1AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorUser1AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorUser1AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorUser1AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user1.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user1.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user1.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorUser1AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser1AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user1.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user1.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1.attribute'
        self.end_value_mode = RootLuRamp_generatorUser1AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorUser1AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorUser1AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorUser1AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorUser1AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorUser1AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorUser1AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorUser1AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorUser1AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorUser1AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user1'
        self.attribute = RootLuRamp_generatorUser1Attribute(self._context)
        self.trigger = RootLuRamp_generatorUser1Trigger(self._context)
        self.busy = RootLuRamp_generatorUser1Busy(self._context)


class RootLuRamp_generatorUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.user4.busy.is_moving'))


class RootLuRamp_generatorUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.user4.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.user4.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.user4.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.user4.trigger.abort')


class RootLuRamp_generatorUser4AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorUser4AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser4AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user4.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user4.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user4.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorUser4AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser4AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.user4.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user4.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user4.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user4.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user4.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user4.attribute.status.enum', list(new_val))


class RootLuRamp_generatorUser4AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorUser4AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorUser4AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorUser4AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorUser4AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorUser4AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user4.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user4.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user4.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorUser4AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser4AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user4.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user4.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4.attribute'
        self.end_value_mode = RootLuRamp_generatorUser4AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorUser4AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorUser4AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorUser4AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorUser4AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorUser4AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorUser4AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorUser4AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorUser4AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorUser4AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user4'
        self.attribute = RootLuRamp_generatorUser4Attribute(self._context)
        self.trigger = RootLuRamp_generatorUser4Trigger(self._context)
        self.busy = RootLuRamp_generatorUser4Busy(self._context)


class RootLuRamp_generatorPosition_xBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.position_x.busy.is_moving'))


class RootLuRamp_generatorPosition_xTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_x.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_x.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_x.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_x.trigger.abort')


class RootLuRamp_generatorPosition_xAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_xAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorPosition_xAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_xAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.position_x.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_x.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_x.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_x.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_x.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_x.attribute.status.enum', list(new_val))


class RootLuRamp_generatorPosition_xAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_x.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_x.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorPosition_xAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_xAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_x.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_x.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorPosition_xAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x.attribute'
        self.end_value_mode = RootLuRamp_generatorPosition_xAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorPosition_xAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorPosition_xAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorPosition_xAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorPosition_xAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorPosition_xAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorPosition_xAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorPosition_xAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorPosition_xAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorPosition_xAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorPosition_x(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_x'
        self.attribute = RootLuRamp_generatorPosition_xAttribute(self._context)
        self.trigger = RootLuRamp_generatorPosition_xTrigger(self._context)
        self.busy = RootLuRamp_generatorPosition_xBusy(self._context)


class RootLuRamp_generatorCtrl_zBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.ctrl_z.busy.is_moving'))


class RootLuRamp_generatorCtrl_zTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.ctrl_z.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.ctrl_z.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.ctrl_z.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.ctrl_z.trigger.abort')


class RootLuRamp_generatorCtrl_zAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorCtrl_zAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorCtrl_zAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorCtrl_zAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.status.enum', list(new_val))


class RootLuRamp_generatorCtrl_zAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorCtrl_zAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorCtrl_zAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.ctrl_z.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorCtrl_zAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z.attribute'
        self.end_value_mode = RootLuRamp_generatorCtrl_zAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorCtrl_zAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorCtrl_zAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorCtrl_zAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorCtrl_zAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorCtrl_zAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorCtrl_zAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorCtrl_zAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorCtrl_zAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorCtrl_zAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorCtrl_z(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.ctrl_z'
        self.attribute = RootLuRamp_generatorCtrl_zAttribute(self._context)
        self.trigger = RootLuRamp_generatorCtrl_zTrigger(self._context)
        self.busy = RootLuRamp_generatorCtrl_zBusy(self._context)


class RootLuRamp_generatorTip_voltageBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.tip_voltage.busy.is_moving'))


class RootLuRamp_generatorTip_voltageTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.tip_voltage.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.tip_voltage.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.tip_voltage.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.tip_voltage.trigger.abort')


class RootLuRamp_generatorTip_voltageAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTip_voltageAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorTip_voltageAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTip_voltageAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.status.enum', list(new_val))


class RootLuRamp_generatorTip_voltageAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorTip_voltageAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTip_voltageAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.tip_voltage.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorTip_voltageAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage.attribute'
        self.end_value_mode = RootLuRamp_generatorTip_voltageAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorTip_voltageAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorTip_voltageAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorTip_voltageAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorTip_voltageAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorTip_voltageAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorTip_voltageAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorTip_voltageAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorTip_voltageAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorTip_voltageAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorTip_voltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.tip_voltage'
        self.attribute = RootLuRamp_generatorTip_voltageAttribute(self._context)
        self.trigger = RootLuRamp_generatorTip_voltageTrigger(self._context)
        self.busy = RootLuRamp_generatorTip_voltageBusy(self._context)


class RootLuRamp_generatorApproachBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.approach.busy.is_moving'))


class RootLuRamp_generatorApproachTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.approach.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.approach.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.approach.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.approach.trigger.abort')


class RootLuRamp_generatorApproachAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorApproachAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorApproachAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.approach.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.approach.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.approach.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorApproachAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorApproachAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.approach.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.approach.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.approach.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.approach.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.approach.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.approach.attribute.status.enum', list(new_val))


class RootLuRamp_generatorApproachAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorApproachAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorApproachAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorApproachAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorApproachAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorApproachAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.approach.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.approach.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.approach.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorApproachAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorApproachAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.approach.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.approach.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorApproachAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach.attribute'
        self.end_value_mode = RootLuRamp_generatorApproachAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorApproachAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorApproachAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorApproachAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorApproachAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorApproachAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorApproachAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorApproachAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorApproachAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorApproachAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.approach'
        self.attribute = RootLuRamp_generatorApproachAttribute(self._context)
        self.trigger = RootLuRamp_generatorApproachTrigger(self._context)
        self.busy = RootLuRamp_generatorApproachBusy(self._context)


class RootLuRamp_generatorVirtual1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.virtual1.busy.is_moving'))


class RootLuRamp_generatorVirtual1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual1.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual1.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual1.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual1.trigger.abort')


class RootLuRamp_generatorVirtual1AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual1AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual1AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual1AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.virtual1.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual1.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual1.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.status.enum', list(new_val))


class RootLuRamp_generatorVirtual1AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual1.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorVirtual1AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual1AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual1.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual1.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1.attribute'
        self.end_value_mode = RootLuRamp_generatorVirtual1AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorVirtual1AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorVirtual1AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorVirtual1AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorVirtual1AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorVirtual1AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorVirtual1AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorVirtual1AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorVirtual1AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorVirtual1AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorVirtual1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual1'
        self.attribute = RootLuRamp_generatorVirtual1Attribute(self._context)
        self.trigger = RootLuRamp_generatorVirtual1Trigger(self._context)
        self.busy = RootLuRamp_generatorVirtual1Busy(self._context)


class RootLuRamp_generatorPosition_yBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.position_y.busy.is_moving'))


class RootLuRamp_generatorPosition_yTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_y.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_y.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_y.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.position_y.trigger.abort')


class RootLuRamp_generatorPosition_yAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_yAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorPosition_yAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_yAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.position_y.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_y.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_y.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_y.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_y.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_y.attribute.status.enum', list(new_val))


class RootLuRamp_generatorPosition_yAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.position_y.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.position_y.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorPosition_yAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPosition_yAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.position_y.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.position_y.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorPosition_yAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y.attribute'
        self.end_value_mode = RootLuRamp_generatorPosition_yAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorPosition_yAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorPosition_yAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorPosition_yAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorPosition_yAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorPosition_yAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorPosition_yAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorPosition_yAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorPosition_yAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorPosition_yAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorPosition_y(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.position_y'
        self.attribute = RootLuRamp_generatorPosition_yAttribute(self._context)
        self.trigger = RootLuRamp_generatorPosition_yTrigger(self._context)
        self.busy = RootLuRamp_generatorPosition_yBusy(self._context)


class RootLuRamp_generatorAlternate_zBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.alternate_z.busy.is_moving'))


class RootLuRamp_generatorAlternate_zTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.alternate_z.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.alternate_z.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.alternate_z.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.alternate_z.trigger.abort')


class RootLuRamp_generatorAlternate_zAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorAlternate_zAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorAlternate_zAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorAlternate_zAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.alternate_z.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.alternate_z.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.alternate_z.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.status.enum', list(new_val))


class RootLuRamp_generatorAlternate_zAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.alternate_z.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorAlternate_zAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorAlternate_zAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.alternate_z.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorAlternate_zAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z.attribute'
        self.end_value_mode = RootLuRamp_generatorAlternate_zAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorAlternate_zAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorAlternate_zAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorAlternate_zAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorAlternate_zAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorAlternate_zAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorAlternate_zAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorAlternate_zAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorAlternate_zAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorAlternate_zAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorAlternate_z(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.alternate_z'
        self.attribute = RootLuRamp_generatorAlternate_zAttribute(self._context)
        self.trigger = RootLuRamp_generatorAlternate_zTrigger(self._context)
        self.busy = RootLuRamp_generatorAlternate_zBusy(self._context)


class RootLuRamp_generatorVirtual2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.virtual2.busy.is_moving'))


class RootLuRamp_generatorVirtual2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual2.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual2.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual2.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.virtual2.trigger.abort')


class RootLuRamp_generatorVirtual2AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual2AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual2AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual2AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.virtual2.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual2.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual2.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.status.enum', list(new_val))


class RootLuRamp_generatorVirtual2AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.virtual2.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorVirtual2AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorVirtual2AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.virtual2.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.virtual2.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorVirtual2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2.attribute'
        self.end_value_mode = RootLuRamp_generatorVirtual2AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorVirtual2AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorVirtual2AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorVirtual2AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorVirtual2AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorVirtual2AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorVirtual2AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorVirtual2AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorVirtual2AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorVirtual2AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorVirtual2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.virtual2'
        self.attribute = RootLuRamp_generatorVirtual2Attribute(self._context)
        self.trigger = RootLuRamp_generatorVirtual2Trigger(self._context)
        self.busy = RootLuRamp_generatorVirtual2Busy(self._context)


class RootLuRamp_generatorPlane_zBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.plane_z.busy.is_moving'))


class RootLuRamp_generatorPlane_zTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.plane_z.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.plane_z.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.plane_z.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.plane_z.trigger.abort')


class RootLuRamp_generatorPlane_zAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPlane_zAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorPlane_zAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPlane_zAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.plane_z.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.plane_z.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.plane_z.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.status.enum', list(new_val))


class RootLuRamp_generatorPlane_zAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.plane_z.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorPlane_zAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorPlane_zAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.plane_z.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.plane_z.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorPlane_zAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z.attribute'
        self.end_value_mode = RootLuRamp_generatorPlane_zAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorPlane_zAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorPlane_zAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorPlane_zAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorPlane_zAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorPlane_zAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorPlane_zAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorPlane_zAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorPlane_zAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorPlane_zAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorPlane_z(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.plane_z'
        self.attribute = RootLuRamp_generatorPlane_zAttribute(self._context)
        self.trigger = RootLuRamp_generatorPlane_zTrigger(self._context)
        self.busy = RootLuRamp_generatorPlane_zBusy(self._context)


class RootLuRamp_generatorUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.user2.busy.is_moving'))


class RootLuRamp_generatorUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.user2.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.user2.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.user2.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.user2.trigger.abort')


class RootLuRamp_generatorUser2AttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorUser2AttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser2AttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user2.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user2.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user2.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorUser2AttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser2AttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.user2.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user2.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user2.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user2.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user2.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user2.attribute.status.enum', list(new_val))


class RootLuRamp_generatorUser2AttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorUser2AttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorUser2AttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorUser2AttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorUser2AttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorUser2AttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.user2.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.user2.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.user2.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorUser2AttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorUser2AttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.user2.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.user2.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2.attribute'
        self.end_value_mode = RootLuRamp_generatorUser2AttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorUser2AttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorUser2AttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorUser2AttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorUser2AttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorUser2AttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorUser2AttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorUser2AttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorUser2AttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorUser2AttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.user2'
        self.attribute = RootLuRamp_generatorUser2Attribute(self._context)
        self.trigger = RootLuRamp_generatorUser2Trigger(self._context)
        self.busy = RootLuRamp_generatorUser2Busy(self._context)


class RootLuRamp_generatorTestBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.busy'

    @property
    def is_moving(self) -> bool:
        return bool(self._context.call('root.lu.ramp_generator.test.busy.is_moving'))


class RootLuRamp_generatorTestTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.ramp_generator.test.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.ramp_generator.test.trigger.stop')

    def prepare(self) -> None:
        return self._context.call('root.lu.ramp_generator.test.trigger.prepare')

    def abort(self) -> None:
        return self._context.call('root.lu.ramp_generator.test.trigger.abort')


class RootLuRamp_generatorTestAttributeEnd_value_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.end_value_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.end_value_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_absolute.value', float(new_val))


class RootLuRamp_generatorTestAttributeMoving_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.moving_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTestAttributeMoving_mode.ValueEnum(self._context.get('root.lu.ramp_generator.test.attribute.moving_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.test.attribute.moving_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.test.attribute.moving_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_mode.enum', list(new_val))


class RootLuRamp_generatorTestAttributeStatus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_moving = 0
        reached_lower_limit = 2
        stopped_by_external_event = 4
        reached_endposition = 1
        reached_upper_limit = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTestAttributeStatus.ValueEnum(self._context.get('root.lu.ramp_generator.test.attribute.status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.test.attribute.status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.test.attribute.status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.test.attribute.status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.test.attribute.status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.test.attribute.status.enum', list(new_val))


class RootLuRamp_generatorTestAttributeUpper_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.upper_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.upper_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.upper_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.upper_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.upper_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.upper_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.upper_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.upper_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.upper_limit.value', float(new_val))


class RootLuRamp_generatorTestAttributeMoving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_speed.value', float(new_val))


class RootLuRamp_generatorTestAttributeEnd_value_relative(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.end_value_relative'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_relative.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_relative.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_relative.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_relative.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.end_value_relative.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_relative.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.end_value_relative.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_relative.value', float(new_val))


class RootLuRamp_generatorTestAttributeCurrent_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.current_value.value', float(new_val))


class RootLuRamp_generatorTestAttributeLower_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.lower_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.lower_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.lower_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.lower_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.lower_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.lower_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.lower_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.lower_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.lower_limit.value', float(new_val))


class RootLuRamp_generatorTestAttributeMoving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.ramp_generator.test.attribute.moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.ramp_generator.test.attribute.moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.ramp_generator.test.attribute.moving_time.value', float(new_val))


class RootLuRamp_generatorTestAttributeEnd_value_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        move_to_absolute = 0
        move_relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute.end_value_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuRamp_generatorTestAttributeEnd_value_mode.ValueEnum(self._context.get('root.lu.ramp_generator.test.attribute.end_value_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.ramp_generator.test.attribute.end_value_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.ramp_generator.test.attribute.end_value_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.ramp_generator.test.attribute.end_value_mode.enum', list(new_val))


class RootLuRamp_generatorTestAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test.attribute'
        self.end_value_mode = RootLuRamp_generatorTestAttributeEnd_value_mode(self._context)
        self.moving_time = RootLuRamp_generatorTestAttributeMoving_time(self._context)
        self.lower_limit = RootLuRamp_generatorTestAttributeLower_limit(self._context)
        self.current_value = RootLuRamp_generatorTestAttributeCurrent_value(self._context)
        self.end_value_relative = RootLuRamp_generatorTestAttributeEnd_value_relative(self._context)
        self.moving_speed = RootLuRamp_generatorTestAttributeMoving_speed(self._context)
        self.upper_limit = RootLuRamp_generatorTestAttributeUpper_limit(self._context)
        self.status = RootLuRamp_generatorTestAttributeStatus(self._context)
        self.moving_mode = RootLuRamp_generatorTestAttributeMoving_mode(self._context)
        self.end_value_absolute = RootLuRamp_generatorTestAttributeEnd_value_absolute(self._context)


class RootLuRamp_generatorTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator.test'
        self.attribute = RootLuRamp_generatorTestAttribute(self._context)
        self.trigger = RootLuRamp_generatorTestTrigger(self._context)
        self.busy = RootLuRamp_generatorTestBusy(self._context)


class RootLuRamp_generator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.ramp_generator'
        self.test = RootLuRamp_generatorTest(self._context)
        self.user2 = RootLuRamp_generatorUser2(self._context)
        self.plane_z = RootLuRamp_generatorPlane_z(self._context)
        self.virtual2 = RootLuRamp_generatorVirtual2(self._context)
        self.alternate_z = RootLuRamp_generatorAlternate_z(self._context)
        self.position_y = RootLuRamp_generatorPosition_y(self._context)
        self.virtual1 = RootLuRamp_generatorVirtual1(self._context)
        self.approach = RootLuRamp_generatorApproach(self._context)
        self.tip_voltage = RootLuRamp_generatorTip_voltage(self._context)
        self.ctrl_z = RootLuRamp_generatorCtrl_z(self._context)
        self.position_x = RootLuRamp_generatorPosition_x(self._context)
        self.user4 = RootLuRamp_generatorUser4(self._context)
        self.user1 = RootLuRamp_generatorUser1(self._context)
        self.virtual0 = RootLuRamp_generatorVirtual0(self._context)


class RootLuDigi_user_ioInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.busy'


class RootLuDigi_user_ioInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.trigger'


class RootLuDigi_user_ioInstanceAttributeDigi_out1_level(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        high = 1
        low = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out1_level'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out1_level.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_level.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_level.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_level.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_level.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_level.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_level.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out1_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out1_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out1_enable.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_enable.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out2_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out2_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out2_enable.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_enable.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out1_pulse(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        t20_ms = 5
        t5_ms = 4
        t5_us = 1
        t500_us = 3
        t0_5_us = 0
        t50_us = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out1_pulse'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out1_pulse.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_pulse.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out1_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        event_falling_edge_pulse = 3
        event_rising_and_falling_edge_pulse = 4
        static_level = 0
        event_rising_edge_pulse = 2
        event_level = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out1_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out1_mode.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_mode.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out2_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        event_falling_edge_pulse = 3
        event_rising_and_falling_edge_pulse = 4
        static_level = 0
        event_rising_edge_pulse = 2
        event_level = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out2_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out2_mode.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_mode.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out2_level(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        high = 1
        low = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out2_level'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out2_level.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_level.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_level.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_level.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_level.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_level.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_level.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out2_pulse(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        t20_ms = 5
        t5_ms = 4
        t5_us = 1
        t500_us = 3
        t0_5_us = 0
        t50_us = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out2_pulse'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out2_pulse.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_pulse.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out2_event_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 25
        ramp_gen_maxz_done = 7
        ramp_gen_alternatez_done = 8
        ramp_gen_test_done = 13
        soft_event0_true = 24
        and_mask0_true = 28
        user_abort_event_true = 27
        z_ctrl_reached_max_z_true = 20
        z_ctrl_reached_min_z_true = 19
        z_ctrl_reached_error_limit_true = 18
        mem_sig_gen_done = 12
        unused_done = 2
        comparator2_true = 30
        ramp_gen_tipvoltage_done = 9
        timer_dbg1_done = 15
        timer_proc0_done = 11
        ramp_gen_positionx_done = 3
        ramp_gen_positiony_done = 4
        data_sampling_done = 1
        data_capture_done = 0
        soft_event2_true = 26
        ramp_gen_approach_done = 10
        ramp_gen_user4_done = 14
        ramp_gen_planez_done = 5
        comparator1_true = 29
        ext_event1_true = 23
        ramp_gen_ctrlz_done = 6
        ext_event0_true = 22
        comparator3_true = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out2_event_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out2_event_source.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out2_event_source.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_in1_level(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        high = 1
        low = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_in1_level'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_in1_level.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in1_level.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in1_level.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in1_level.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in1_level.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in1_level.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in1_level.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_in2_level(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        high = 1
        low = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_in2_level'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_in2_level.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in2_level.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in2_level.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in2_level.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in2_level.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_in2_level.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_in2_level.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttributeDigi_out1_event_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        soft_event1_true = 25
        ramp_gen_maxz_done = 7
        ramp_gen_alternatez_done = 8
        ramp_gen_test_done = 13
        soft_event0_true = 24
        and_mask0_true = 28
        user_abort_event_true = 27
        z_ctrl_reached_max_z_true = 20
        z_ctrl_reached_min_z_true = 19
        z_ctrl_reached_error_limit_true = 18
        mem_sig_gen_done = 12
        unused_done = 2
        comparator2_true = 30
        ramp_gen_tipvoltage_done = 9
        timer_dbg1_done = 15
        timer_proc0_done = 11
        ramp_gen_positionx_done = 3
        ramp_gen_positiony_done = 4
        data_sampling_done = 1
        data_capture_done = 0
        soft_event2_true = 26
        ramp_gen_approach_done = 10
        ramp_gen_user4_done = 14
        ramp_gen_planez_done = 5
        comparator1_true = 29
        ext_event1_true = 23
        ramp_gen_ctrlz_done = 6
        ext_event0_true = 22
        comparator3_true = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute.digi_out1_event_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDigi_user_ioInstanceAttributeDigi_out1_event_source.ValueEnum(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.digi_user_io.instance.attribute.digi_out1_event_source.enum', list(new_val))


class RootLuDigi_user_ioInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance.attribute'
        self.digi_out1_event_source = RootLuDigi_user_ioInstanceAttributeDigi_out1_event_source(self._context)
        self.digi_in2_level = RootLuDigi_user_ioInstanceAttributeDigi_in2_level(self._context)
        self.digi_in1_level = RootLuDigi_user_ioInstanceAttributeDigi_in1_level(self._context)
        self.digi_out2_event_source = RootLuDigi_user_ioInstanceAttributeDigi_out2_event_source(self._context)
        self.digi_out2_pulse = RootLuDigi_user_ioInstanceAttributeDigi_out2_pulse(self._context)
        self.digi_out2_level = RootLuDigi_user_ioInstanceAttributeDigi_out2_level(self._context)
        self.digi_out2_mode = RootLuDigi_user_ioInstanceAttributeDigi_out2_mode(self._context)
        self.digi_out1_mode = RootLuDigi_user_ioInstanceAttributeDigi_out1_mode(self._context)
        self.digi_out1_pulse = RootLuDigi_user_ioInstanceAttributeDigi_out1_pulse(self._context)
        self.digi_out2_enable = RootLuDigi_user_ioInstanceAttributeDigi_out2_enable(self._context)
        self.digi_out1_enable = RootLuDigi_user_ioInstanceAttributeDigi_out1_enable(self._context)
        self.digi_out1_level = RootLuDigi_user_ioInstanceAttributeDigi_out1_level(self._context)


class RootLuDigi_user_ioInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io.instance'
        self.attribute = RootLuDigi_user_ioInstanceAttribute(self._context)
        self.trigger = RootLuDigi_user_ioInstanceTrigger(self._context)
        self.busy = RootLuDigi_user_ioInstanceBusy(self._context)


class RootLuDigi_user_io(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.digi_user_io'
        self.instance = RootLuDigi_user_ioInstance(self._context)


class RootLuSystem_infraInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.busy'


class RootLuSystem_infraInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.trigger'

    def detect_limit_switch_status_info_change(self) -> None:
        return self._context.call('root.lu.system_infra.instance.trigger.detect_limit_switch_status_info_change')

    def detect_scan_head_arrival_removal(self) -> None:
        return self._context.call('root.lu.system_infra.instance.trigger.detect_scan_head_arrival_removal')

    def switch_clock_source(self) -> None:
        return self._context.call('root.lu.system_infra.instance.trigger.switch_clock_source')

    def detect_scan_head_lever_change(self) -> None:
        return self._context.call('root.lu.system_infra.instance.trigger.detect_scan_head_lever_change')


class RootLuSystem_infraInstanceAttributeCurrent_clock_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        internal = 0
        external = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.current_clock_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeCurrent_clock_source.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.current_clock_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.current_clock_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.current_clock_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.current_clock_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.current_clock_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.current_clock_source.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeDepreciated_1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.depreciated_1'


class RootLuSystem_infraInstanceAttributeTarget_clock_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        internal = 0
        external = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.target_clock_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeTarget_clock_source.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.target_clock_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.target_clock_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.target_clock_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.target_clock_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.target_clock_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.target_clock_source.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeHas_video_source_detection(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.has_video_source_detection'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_video_source_detection.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_video_source_detection.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_video_source_detection.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_video_source_detection.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.has_video_source_detection.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.has_video_source_detection.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_video_source_detection.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_video_source_detection.value', float(new_val))


class RootLuSystem_infraInstanceAttributeInterface_box_type(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        i100 = 2
        i100_afsem = 3
        icxflex = 7
        unknown = 0
        not_connected = 1
        icxp6 = 8
        i100_integrated = 4
        icxarac = 5
        icxcytomass = 6

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.interface_box_type'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeInterface_box_type.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.interface_box_type.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.interface_box_type.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.interface_box_type.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.interface_box_type.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.interface_box_type.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.interface_box_type.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeLaser_power_current(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.laser_power_current'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_current.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_current.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_current.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_current.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.laser_power_current.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_current.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_current.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_current.value', float(new_val))


class RootLuSystem_infraInstanceAttributeApproach_motor_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.approach_motor_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_position.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_position.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_position.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_position.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_position.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_position.value', float(new_val))


class RootLuSystem_infraInstanceAttributeLaser_power_lock(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.laser_power_lock'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_lock.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_lock.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_lock.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_lock.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.laser_power_lock.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_lock.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_lock.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_lock.value', float(new_val))


class RootLuSystem_infraInstanceAttributeMain_in1_coupling(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        dc_coupling = 1
        ac_coupling = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.main_in1_coupling'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeMain_in1_coupling.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.main_in1_coupling.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_coupling.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.main_in1_coupling.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_coupling.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.main_in1_coupling.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_coupling.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeMain_in1_gain(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        gain1 = 0
        gain4 = 1
        gain16 = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.main_in1_gain'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeMain_in1_gain.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.main_in1_gain.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_gain.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.main_in1_gain.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_gain.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.main_in1_gain.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.main_in1_gain.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeControl_laser_power(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.control_laser_power'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.control_laser_power.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.control_laser_power.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.control_laser_power.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.control_laser_power.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.control_laser_power.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.control_laser_power.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.control_laser_power.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.control_laser_power.value', float(new_val))


class RootLuSystem_infraInstanceAttributeMain_in2_coupling(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        dc_coupling = 1
        ac_coupling = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.main_in2_coupling'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeMain_in2_coupling.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.main_in2_coupling.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_coupling.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.main_in2_coupling.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_coupling.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.main_in2_coupling.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_coupling.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeMain_in2_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        test_tip_voltage = 8
        user2 = 3
        deflection = 0
        test_ref = 7
        lateral = 1
        user1 = 2
        tip_current = 4
        test_ana_gnd = 6
        user3 = 5

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.main_in2_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeMain_in2_input.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.main_in2_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.main_in2_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.main_in2_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_input.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeScan_head_type(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.scan_head_type'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.scan_head_type.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.scan_head_type.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.scan_head_type.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.scan_head_type.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.scan_head_type.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.scan_head_type.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.scan_head_type.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.scan_head_type.value', float(new_val))


class RootLuSystem_infraInstanceAttributeEnable10_hz_update_sensor_status(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.enable10_hz_update_sensor_status.value', float(new_val))


class RootLuSystem_infraInstanceAttributeAfm_sensor_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        low = 1
        fail = 4
        undefined = 0
        ok = 2
        high = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.afm_sensor_status'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status.unit', str(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status.enum', list(new_val))

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeAfm_sensor_status.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status.value_raw', new_val.value)


class RootLuSystem_infraInstanceAttributeTip_signal_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        voltage_output = 1
        current_sense_input = 0
        external_feedthrough = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.tip_signal_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeTip_signal_mode.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.tip_signal_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.tip_signal_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.tip_signal_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.tip_signal_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.tip_signal_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.tip_signal_mode.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeMain_in2_gain(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        gain1 = 0
        gain4 = 1
        gain16 = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.main_in2_gain'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeMain_in2_gain.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.main_in2_gain.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_gain.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.main_in2_gain.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_gain.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.main_in2_gain.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.main_in2_gain.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeSensor_value_normalized(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.sensor_value_normalized'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_value_normalized.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_value_normalized.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_value_normalized.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_value_normalized.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.sensor_value_normalized.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_value_normalized.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_value_normalized.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_value_normalized.value', float(new_val))


class RootLuSystem_infraInstanceAttributeDepreciated_0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.depreciated_0'


class RootLuSystem_infraInstanceAttributeExtra_in1_input(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.extra_in1_input'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.extra_in1_input.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.extra_in1_input.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.extra_in1_input.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.extra_in1_input.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.extra_in1_input.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.extra_in1_input.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.extra_in1_input.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.extra_in1_input.value', float(new_val))


class RootLuSystem_infraInstanceAttributeController_temperature(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.controller_temperature'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.controller_temperature.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.controller_temperature.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.controller_temperature.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.controller_temperature.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.controller_temperature.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.controller_temperature.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.controller_temperature.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.controller_temperature.value', float(new_val))


class RootLuSystem_infraInstanceAttributeSensor_light(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.sensor_light'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_light.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_light.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_light.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_light.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.sensor_light.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_light.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.sensor_light.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.sensor_light.value', float(new_val))


class RootLuSystem_infraInstanceAttributeCurrent_video_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        side_view = 2
        top_view = 1
        undefined = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.current_video_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeCurrent_video_source.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.current_video_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.current_video_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.current_video_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.current_video_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.current_video_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.current_video_source.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeDepreciated_2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.depreciated_2'


class RootLuSystem_infraInstanceAttributeCurrent_scanhead_tilt_position(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        working_pos = 1
        open_pos = 2
        undefined = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.current_scanhead_tilt_position'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeCurrent_scanhead_tilt_position.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.current_scanhead_tilt_position.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeController_type(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        c3000_i = 5
        c3000 = 2
        core_afm = 3
        unknown = 0
        cx = 4

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.controller_type'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeController_type.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.controller_type.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.controller_type.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.controller_type.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.controller_type.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.controller_type.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.controller_type.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeDeflection_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.deflection_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.deflection_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.deflection_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.deflection_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.deflection_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.deflection_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.deflection_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.deflection_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.deflection_offset.value', float(new_val))


class RootLuSystem_infraInstanceAttributeApproach_motor_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        limit_switches = 1
        undefined = 0
        position_sensor = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.approach_motor_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeApproach_motor_mode.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_mode.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeAfm_sensor_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        laser_drive = 1
        detector_intensity = 3
        undefined = 0
        laser_power = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.afm_sensor_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_mode.unit', str(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_mode.enum', list(new_val))

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeAfm_sensor_mode.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_mode.value_raw', new_val.value)


class RootLuSystem_infraInstanceAttributeLaser_power_absolute(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.laser_power_absolute'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_absolute.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_absolute.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_absolute.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_absolute.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.laser_power_absolute.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_absolute.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.laser_power_absolute.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.laser_power_absolute.value', float(new_val))


class RootLuSystem_infraInstanceAttributeTip_current_or_in_user3_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        in_user3 = 1
        tip_current = 0
        ana_gnd = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeTip_current_or_in_user3_input.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.tip_current_or_in_user3_input.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeApproach_motor_status_normalized(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.approach_motor_status_normalized'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status_normalized.value', float(new_val))


class RootLuSystem_infraInstanceAttributeFast_out2_output_mask(wrap.CmdTreeProp):

    class ValueMask(enum.IntEnum):
        monitor1 = 1
        monitor2 = 2
        all = 31
        user_out1 = 8
        tip_voltage_or_user_out_a = 4
        none = 0
        user_out_b = 16

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.fast_out2_output_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.fast_out2_output_mask.value_raw'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.fast_out2_output_mask.value_raw', int(new_val))

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.fast_out2_output_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.fast_out2_output_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.fast_out2_output_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.fast_out2_output_mask.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeFriction_normalized(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.friction_normalized'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.friction_normalized.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.friction_normalized.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.friction_normalized.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.friction_normalized.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.friction_normalized.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.friction_normalized.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.friction_normalized.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.friction_normalized.value', float(new_val))


class RootLuSystem_infraInstanceAttributeApproach_motor_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        not_connected = 4
        min_in = 2
        dummy_0 = 0
        max_out = 3
        error = 5
        in_range = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.approach_motor_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSystem_infraInstanceAttributeApproach_motor_status.ValueEnum(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.system_infra.instance.attribute.approach_motor_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.system_infra.instance.attribute.approach_motor_status.enum', list(new_val))


class RootLuSystem_infraInstanceAttributeAfm_sensor_status_normalized(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.afm_sensor_status_normalized'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.afm_sensor_status_normalized.value', float(new_val))


class RootLuSystem_infraInstanceAttributeHas_scanhead_tilt_detection(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.system_infra.instance.attribute.has_scanhead_tilt_detection.value', float(new_val))


class RootLuSystem_infraInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance.attribute'
        self.has_scanhead_tilt_detection = RootLuSystem_infraInstanceAttributeHas_scanhead_tilt_detection(self._context)
        self.afm_sensor_status_normalized = RootLuSystem_infraInstanceAttributeAfm_sensor_status_normalized(self._context)
        self.approach_motor_status = RootLuSystem_infraInstanceAttributeApproach_motor_status(self._context)
        self.friction_normalized = RootLuSystem_infraInstanceAttributeFriction_normalized(self._context)
        self.fast_out2_output_mask = RootLuSystem_infraInstanceAttributeFast_out2_output_mask(self._context)
        self.approach_motor_status_normalized = RootLuSystem_infraInstanceAttributeApproach_motor_status_normalized(self._context)
        self.tip_current_or_in_user3_input = RootLuSystem_infraInstanceAttributeTip_current_or_in_user3_input(self._context)
        self.laser_power_absolute = RootLuSystem_infraInstanceAttributeLaser_power_absolute(self._context)
        self.afm_sensor_mode = RootLuSystem_infraInstanceAttributeAfm_sensor_mode(self._context)
        self.approach_motor_mode = RootLuSystem_infraInstanceAttributeApproach_motor_mode(self._context)
        self.deflection_offset = RootLuSystem_infraInstanceAttributeDeflection_offset(self._context)
        self.controller_type = RootLuSystem_infraInstanceAttributeController_type(self._context)
        self.current_scanhead_tilt_position = RootLuSystem_infraInstanceAttributeCurrent_scanhead_tilt_position(self._context)
        self.depreciated_2 = RootLuSystem_infraInstanceAttributeDepreciated_2(self._context)
        self.current_video_source = RootLuSystem_infraInstanceAttributeCurrent_video_source(self._context)
        self.sensor_light = RootLuSystem_infraInstanceAttributeSensor_light(self._context)
        self.controller_temperature = RootLuSystem_infraInstanceAttributeController_temperature(self._context)
        self.extra_in1_input = RootLuSystem_infraInstanceAttributeExtra_in1_input(self._context)
        self.depreciated_0 = RootLuSystem_infraInstanceAttributeDepreciated_0(self._context)
        self.sensor_value_normalized = RootLuSystem_infraInstanceAttributeSensor_value_normalized(self._context)
        self.main_in2_gain = RootLuSystem_infraInstanceAttributeMain_in2_gain(self._context)
        self.tip_signal_mode = RootLuSystem_infraInstanceAttributeTip_signal_mode(self._context)
        self.afm_sensor_status = RootLuSystem_infraInstanceAttributeAfm_sensor_status(self._context)
        self.enable10_hz_update_sensor_status = RootLuSystem_infraInstanceAttributeEnable10_hz_update_sensor_status(self._context)
        self.scan_head_type = RootLuSystem_infraInstanceAttributeScan_head_type(self._context)
        self.main_in2_input = RootLuSystem_infraInstanceAttributeMain_in2_input(self._context)
        self.main_in2_coupling = RootLuSystem_infraInstanceAttributeMain_in2_coupling(self._context)
        self.control_laser_power = RootLuSystem_infraInstanceAttributeControl_laser_power(self._context)
        self.main_in1_gain = RootLuSystem_infraInstanceAttributeMain_in1_gain(self._context)
        self.main_in1_coupling = RootLuSystem_infraInstanceAttributeMain_in1_coupling(self._context)
        self.laser_power_lock = RootLuSystem_infraInstanceAttributeLaser_power_lock(self._context)
        self.approach_motor_position = RootLuSystem_infraInstanceAttributeApproach_motor_position(self._context)
        self.laser_power_current = RootLuSystem_infraInstanceAttributeLaser_power_current(self._context)
        self.interface_box_type = RootLuSystem_infraInstanceAttributeInterface_box_type(self._context)
        self.has_video_source_detection = RootLuSystem_infraInstanceAttributeHas_video_source_detection(self._context)
        self.target_clock_source = RootLuSystem_infraInstanceAttributeTarget_clock_source(self._context)
        self.depreciated_1 = RootLuSystem_infraInstanceAttributeDepreciated_1(self._context)
        self.current_clock_source = RootLuSystem_infraInstanceAttributeCurrent_clock_source(self._context)


class RootLuSystem_infraInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra.instance'
        self.attribute = RootLuSystem_infraInstanceAttribute(self._context)
        self.trigger = RootLuSystem_infraInstanceTrigger(self._context)
        self.busy = RootLuSystem_infraInstanceBusy(self._context)


class RootLuSystem_infra(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.system_infra'
        self.instance = RootLuSystem_infraInstance(self._context)


class RootLuTestInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.test.instance.busy'


class RootLuTestInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.test.instance.trigger'

    def force_all_dac_to_max(self) -> None:
        return self._context.call('root.lu.test.instance.trigger.force_all_dac_to_max')

    def force_all_dac_to_zero(self) -> None:
        return self._context.call('root.lu.test.instance.trigger.force_all_dac_to_zero')

    def force_all_dac_to_min(self) -> None:
        return self._context.call('root.lu.test.instance.trigger.force_all_dac_to_min')


class RootLuTestInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.test.instance.attribute'


class RootLuTestInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.test.instance'
        self.attribute = RootLuTestInstanceAttribute(self._context)
        self.trigger = RootLuTestInstanceTrigger(self._context)
        self.busy = RootLuTestInstanceBusy(self._context)


class RootLuTest(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.test'
        self.instance = RootLuTestInstance(self._context)


class RootLuTimerProc0Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.busy'

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.timer.proc0.busy.is_busy'))


class RootLuTimerProc0Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.timer.proc0.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.timer.proc0.trigger.stop')

    def abort(self) -> None:
        return self._context.call('root.lu.timer.proc0.trigger.abort')


class RootLuTimerProc0AttributeCurrent_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.current_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.current_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.current_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.current_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.current_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.proc0.attribute.current_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.proc0.attribute.current_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.current_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.current_time.value', float(new_val))


class RootLuTimerProc0AttributeCounter_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.counter_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.proc0.attribute.counter_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.proc0.attribute.counter_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_max.value', float(new_val))


class RootLuTimerProc0AttributeDelay_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.delay_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.delay_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.delay_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.delay_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.delay_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.proc0.attribute.delay_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.proc0.attribute.delay_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.delay_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.delay_time.value', float(new_val))


class RootLuTimerProc0AttributeCounter_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        digital_sync2 = 1
        digital_sync1 = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.counter_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuTimerProc0AttributeCounter_input.ValueEnum(self._context.get('root.lu.timer.proc0.attribute.counter_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.timer.proc0.attribute.counter_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.timer.proc0.attribute.counter_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.timer.proc0.attribute.counter_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.timer.proc0.attribute.counter_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.timer.proc0.attribute.counter_input.enum', list(new_val))


class RootLuTimerProc0AttributeMode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        event_counter = 1
        delay_timer = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuTimerProc0AttributeMode.ValueEnum(self._context.get('root.lu.timer.proc0.attribute.mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.timer.proc0.attribute.mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.timer.proc0.attribute.mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.timer.proc0.attribute.mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.timer.proc0.attribute.mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.timer.proc0.attribute.mode.enum', list(new_val))


class RootLuTimerProc0AttributeCounter_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute.counter_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.proc0.attribute.counter_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.proc0.attribute.counter_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.proc0.attribute.counter_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.proc0.attribute.counter_value.value', float(new_val))


class RootLuTimerProc0Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0.attribute'
        self.counter_value = RootLuTimerProc0AttributeCounter_value(self._context)
        self.mode = RootLuTimerProc0AttributeMode(self._context)
        self.counter_input = RootLuTimerProc0AttributeCounter_input(self._context)
        self.delay_time = RootLuTimerProc0AttributeDelay_time(self._context)
        self.counter_max = RootLuTimerProc0AttributeCounter_max(self._context)
        self.current_time = RootLuTimerProc0AttributeCurrent_time(self._context)


class RootLuTimerProc0(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.proc0'
        self.attribute = RootLuTimerProc0Attribute(self._context)
        self.trigger = RootLuTimerProc0Trigger(self._context)
        self.busy = RootLuTimerProc0Busy(self._context)


class RootLuTimerDbg1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.busy'

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.timer.dbg1.busy.is_busy'))


class RootLuTimerDbg1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.timer.dbg1.trigger.start')

    def stop(self) -> None:
        return self._context.call('root.lu.timer.dbg1.trigger.stop')

    def abort(self) -> None:
        return self._context.call('root.lu.timer.dbg1.trigger.abort')


class RootLuTimerDbg1AttributeCurrent_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.current_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.current_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.current_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.current_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.current_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.dbg1.attribute.current_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.dbg1.attribute.current_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.current_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.current_time.value', float(new_val))


class RootLuTimerDbg1AttributeCounter_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.counter_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.dbg1.attribute.counter_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.dbg1.attribute.counter_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_max.value', float(new_val))


class RootLuTimerDbg1AttributeDelay_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.delay_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.delay_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.delay_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.delay_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.delay_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.dbg1.attribute.delay_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.dbg1.attribute.delay_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.delay_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.delay_time.value', float(new_val))


class RootLuTimerDbg1AttributeCounter_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        digital_sync2 = 1
        digital_sync1 = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.counter_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuTimerDbg1AttributeCounter_input.ValueEnum(self._context.get('root.lu.timer.dbg1.attribute.counter_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.timer.dbg1.attribute.counter_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.timer.dbg1.attribute.counter_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.timer.dbg1.attribute.counter_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.timer.dbg1.attribute.counter_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.timer.dbg1.attribute.counter_input.enum', list(new_val))


class RootLuTimerDbg1AttributeMode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        event_counter = 1
        delay_timer = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuTimerDbg1AttributeMode.ValueEnum(self._context.get('root.lu.timer.dbg1.attribute.mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.timer.dbg1.attribute.mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.timer.dbg1.attribute.mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.timer.dbg1.attribute.mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.timer.dbg1.attribute.mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.timer.dbg1.attribute.mode.enum', list(new_val))


class RootLuTimerDbg1AttributeCounter_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute.counter_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.timer.dbg1.attribute.counter_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.timer.dbg1.attribute.counter_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.timer.dbg1.attribute.counter_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.timer.dbg1.attribute.counter_value.value', float(new_val))


class RootLuTimerDbg1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1.attribute'
        self.counter_value = RootLuTimerDbg1AttributeCounter_value(self._context)
        self.mode = RootLuTimerDbg1AttributeMode(self._context)
        self.counter_input = RootLuTimerDbg1AttributeCounter_input(self._context)
        self.delay_time = RootLuTimerDbg1AttributeDelay_time(self._context)
        self.counter_max = RootLuTimerDbg1AttributeCounter_max(self._context)
        self.current_time = RootLuTimerDbg1AttributeCurrent_time(self._context)


class RootLuTimerDbg1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer.dbg1'
        self.attribute = RootLuTimerDbg1Attribute(self._context)
        self.trigger = RootLuTimerDbg1Trigger(self._context)
        self.busy = RootLuTimerDbg1Busy(self._context)


class RootLuTimer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.timer'
        self.dbg1 = RootLuTimerDbg1(self._context)
        self.proc0 = RootLuTimerProc0(self._context)


class RootLuZ_controller_exInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.busy'


class RootLuZ_controller_exInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.start')

    def apply_max_z_value(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.apply_max_z_value')

    def abort(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.abort')

    def stop(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.stop')

    def wait_for_z_controller_adjust(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.wait_for_z_controller_adjust')

    def switch_to_target_output_channel(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.switch_to_target_output_channel')

    def init_phase_move(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.init_phase_move')

    def start_simple(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.start_simple')

    def update_base_line_pos(self) -> None:
        return self._context.call('root.lu.z_controller_ex.instance.trigger.update_base_line_pos')


class RootLuZ_controller_exInstanceAttributeZ_controller_adjust_timed_out(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.z_controller_adjust_timed_out.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeDdc_filter_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.ddc_filter_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_rate.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_end_mode_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        pause = 2
        move_relative = 1
        move_to_absolute = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_end_mode_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_end_mode_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_end_mode_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_end_mode_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_end_mode_vec.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_feedback_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        max_retracted = 1
        max_extended = 2
        in_range = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_feedback_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeCurrent_feedback_status.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.current_feedback_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_feedback_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.current_feedback_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_feedback_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.current_feedback_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_feedback_status.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeOutput_compare_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.output_compare_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMax_z_current_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.max_z_current_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_current_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_current_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_current_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_current_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_current_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_current_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_current_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_current_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_error_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_error_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_error_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_error_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_error_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_error_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_error_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_error_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_error_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_error_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeBase_line_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.base_line_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.base_line_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_line_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.base_line_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_line_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.base_line_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_line_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.base_line_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_line_pos.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMin_z_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.min_z_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.min_z_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.min_z_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.min_z_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.min_z_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.min_z_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.min_z_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.min_z_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.min_z_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_limited_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_limited_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_limited_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_limited_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_limited_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_limited_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_limited_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_limited_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_limited_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_limited_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeClosed_loop_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_i_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeOutput_compare_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        equal_or_lower_than = 1
        equal_or_higher_than = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.output_compare_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeOutput_compare_mode.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.output_compare_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_compare_mode.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeDdc_filter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_coeff_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeIntegral_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.integral_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.integral_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.integral_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.integral_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.integral_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.integral_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.integral_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.integral_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.integral_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMax_z_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.max_z_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMax_z_value_change_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.max_z_value_change_speed.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_output_channel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_output_channel'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_channel.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_channel.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_channel.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_channel.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_channel.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_channel.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_channel.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_channel.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeDdc_filter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.ddc_filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ddc_filter_number.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeCtrl_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.ctrl_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeCtrl_input.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.ctrl_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ctrl_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.ctrl_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ctrl_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.ctrl_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.ctrl_input.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributePhase_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_count.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_init_phase_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_init_phase_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_init_phase_count.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_work_mode_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_drive = 1
        z_feedback = 2
        z_closed_loop = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_work_mode_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_work_mode_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_work_mode_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_work_mode_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_work_mode_vec.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_status_flags(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_status_flags'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_status_flags.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_status_flags.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_status_flags.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_status_flags.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_status_flags.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_status_flags.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_status_flags.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_status_flags.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_mode_vec(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_time = 0
        fix_speed = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_mode_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_mode_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_mode_vec.vector', list(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_mode_vec.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_mode_vec.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_speed_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_speed_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeClosed_loop_d_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_d_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_stop_by_value_active_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_stop_by_value_active_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeFeedback_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.feedback_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeFeedback_polarity.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.feedback_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.feedback_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.feedback_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.feedback_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.feedback_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.feedback_polarity.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeProportional_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.proportional_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.proportional_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.proportional_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.proportional_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.proportional_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.proportional_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.proportional_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.proportional_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.proportional_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_pause_time_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_pause_time_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeSet_point(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.set_point'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_output_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeTarget_output_channel(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        out_position_z = 0
        out_external_z = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.target_output_channel'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeTarget_output_channel.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.target_output_channel.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.target_output_channel.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.target_output_channel.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.target_output_channel.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.target_output_channel.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.target_output_channel.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_input_filtered_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_input_filtered_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_filtered_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_pid_command_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_pid_command_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_pid_command_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_time_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_time_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_time_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeOutput_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.output_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeOutput_modulation_enable.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.output_modulation_enable.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeClosed_loop_p_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_p_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeNumber_of_pid_gain_sets(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.number_of_pid_gain_sets.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeInput_compare_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        equal_or_lower_than = 1
        equal_or_higher_than = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.input_compare_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeInput_compare_mode.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_mode.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_phase.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_input_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeClosed_loop_polarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.closed_loop_polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.closed_loop_polarity.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_real_end_pos_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_real_end_pos_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeInput_compare_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.input_compare_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.input_compare_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.input_compare_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributePhase_move_value_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.phase_move_value_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.phase_move_value_vec.vector', list(new_val))


class RootLuZ_controller_exInstanceAttributeDifferential_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.differential_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.differential_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.differential_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.differential_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.differential_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.differential_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.differential_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.differential_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.differential_gain.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeActive_pid_gain_set(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        out_external_z = 1
        out_position_z = 0
        user = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.active_pid_gain_set'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeActive_pid_gain_set.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.active_pid_gain_set.enum', list(new_val))


class RootLuZ_controller_exInstanceAttributeCurrent_sum_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.current_sum_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_sum_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_sum_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_sum_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_sum_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.z_controller_ex.instance.attribute.current_sum_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_sum_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.z_controller_ex.instance.attribute.current_sum_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.z_controller_ex.instance.attribute.current_sum_value.value', float(new_val))


class RootLuZ_controller_exInstanceAttributeBase_work_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_drive = 1
        z_feedback = 2
        z_closed_loop = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute.base_work_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuZ_controller_exInstanceAttributeBase_work_mode.ValueEnum(self._context.get('root.lu.z_controller_ex.instance.attribute.base_work_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_work_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.z_controller_ex.instance.attribute.base_work_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_work_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.z_controller_ex.instance.attribute.base_work_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.z_controller_ex.instance.attribute.base_work_mode.enum', list(new_val))


class RootLuZ_controller_exInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance.attribute'
        self.base_work_mode = RootLuZ_controller_exInstanceAttributeBase_work_mode(self._context)
        self.current_sum_value = RootLuZ_controller_exInstanceAttributeCurrent_sum_value(self._context)
        self.active_pid_gain_set = RootLuZ_controller_exInstanceAttributeActive_pid_gain_set(self._context)
        self.differential_gain = RootLuZ_controller_exInstanceAttributeDifferential_gain(self._context)
        self.phase_move_value_vec = RootLuZ_controller_exInstanceAttributePhase_move_value_vec(self._context)
        self.input_compare_value = RootLuZ_controller_exInstanceAttributeInput_compare_value(self._context)
        self.phase_real_end_pos_vec = RootLuZ_controller_exInstanceAttributePhase_real_end_pos_vec(self._context)
        self.closed_loop_polarity = RootLuZ_controller_exInstanceAttributeClosed_loop_polarity(self._context)
        self.current_input_value = RootLuZ_controller_exInstanceAttributeCurrent_input_value(self._context)
        self.current_phase = RootLuZ_controller_exInstanceAttributeCurrent_phase(self._context)
        self.input_compare_mode = RootLuZ_controller_exInstanceAttributeInput_compare_mode(self._context)
        self.memory_signal_gen_position_enable = RootLuZ_controller_exInstanceAttributeMemory_signal_gen_position_enable(self._context)
        self.number_of_pid_gain_sets = RootLuZ_controller_exInstanceAttributeNumber_of_pid_gain_sets(self._context)
        self.closed_loop_p_gain = RootLuZ_controller_exInstanceAttributeClosed_loop_p_gain(self._context)
        self.output_modulation_enable = RootLuZ_controller_exInstanceAttributeOutput_modulation_enable(self._context)
        self.phase_move_time_vec = RootLuZ_controller_exInstanceAttributePhase_move_time_vec(self._context)
        self.current_pid_command_value = RootLuZ_controller_exInstanceAttributeCurrent_pid_command_value(self._context)
        self.current_input_filtered_value = RootLuZ_controller_exInstanceAttributeCurrent_input_filtered_value(self._context)
        self.target_output_channel = RootLuZ_controller_exInstanceAttributeTarget_output_channel(self._context)
        self.set_point_modulation_enable = RootLuZ_controller_exInstanceAttributeSet_point_modulation_enable(self._context)
        self.current_output_value = RootLuZ_controller_exInstanceAttributeCurrent_output_value(self._context)
        self.set_point = RootLuZ_controller_exInstanceAttributeSet_point(self._context)
        self.phase_pause_time_vec = RootLuZ_controller_exInstanceAttributePhase_pause_time_vec(self._context)
        self.proportional_gain = RootLuZ_controller_exInstanceAttributeProportional_gain(self._context)
        self.feedback_polarity = RootLuZ_controller_exInstanceAttributeFeedback_polarity(self._context)
        self.phase_move_stop_by_value_active_vec = RootLuZ_controller_exInstanceAttributePhase_move_stop_by_value_active_vec(self._context)
        self.closed_loop_d_gain = RootLuZ_controller_exInstanceAttributeClosed_loop_d_gain(self._context)
        self.phase_move_speed_vec = RootLuZ_controller_exInstanceAttributePhase_move_speed_vec(self._context)
        self.phase_move_mode_vec = RootLuZ_controller_exInstanceAttributePhase_move_mode_vec(self._context)
        self.current_status_flags = RootLuZ_controller_exInstanceAttributeCurrent_status_flags(self._context)
        self.phase_work_mode_vec = RootLuZ_controller_exInstanceAttributePhase_work_mode_vec(self._context)
        self.phase_init_phase_count = RootLuZ_controller_exInstanceAttributePhase_init_phase_count(self._context)
        self.phase_count = RootLuZ_controller_exInstanceAttributePhase_count(self._context)
        self.ctrl_input = RootLuZ_controller_exInstanceAttributeCtrl_input(self._context)
        self.filter_coeff_vec = RootLuZ_controller_exInstanceAttributeFilter_coeff_vec(self._context)
        self.ddc_filter_number = RootLuZ_controller_exInstanceAttributeDdc_filter_number(self._context)
        self.current_output_channel = RootLuZ_controller_exInstanceAttributeCurrent_output_channel(self._context)
        self.max_z_value_change_speed = RootLuZ_controller_exInstanceAttributeMax_z_value_change_speed(self._context)
        self.max_z_value = RootLuZ_controller_exInstanceAttributeMax_z_value(self._context)
        self.integral_gain = RootLuZ_controller_exInstanceAttributeIntegral_gain(self._context)
        self.ddc_filter_coeff_vec = RootLuZ_controller_exInstanceAttributeDdc_filter_coeff_vec(self._context)
        self.output_compare_mode = RootLuZ_controller_exInstanceAttributeOutput_compare_mode(self._context)
        self.closed_loop_i_gain = RootLuZ_controller_exInstanceAttributeClosed_loop_i_gain(self._context)
        self.current_limited_value = RootLuZ_controller_exInstanceAttributeCurrent_limited_value(self._context)
        self.min_z_value = RootLuZ_controller_exInstanceAttributeMin_z_value(self._context)
        self.base_line_pos = RootLuZ_controller_exInstanceAttributeBase_line_pos(self._context)
        self.memory_signal_gen_drive_enable = RootLuZ_controller_exInstanceAttributeMemory_signal_gen_drive_enable(self._context)
        self.current_error_value = RootLuZ_controller_exInstanceAttributeCurrent_error_value(self._context)
        self.max_z_current_value = RootLuZ_controller_exInstanceAttributeMax_z_current_value(self._context)
        self.output_compare_value = RootLuZ_controller_exInstanceAttributeOutput_compare_value(self._context)
        self.current_feedback_status = RootLuZ_controller_exInstanceAttributeCurrent_feedback_status(self._context)
        self.phase_move_end_mode_vec = RootLuZ_controller_exInstanceAttributePhase_move_end_mode_vec(self._context)
        self.ddc_filter_rate = RootLuZ_controller_exInstanceAttributeDdc_filter_rate(self._context)
        self.z_controller_adjust_timed_out = RootLuZ_controller_exInstanceAttributeZ_controller_adjust_timed_out(self._context)


class RootLuZ_controller_exInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex.instance'
        self.attribute = RootLuZ_controller_exInstanceAttribute(self._context)
        self.trigger = RootLuZ_controller_exInstanceTrigger(self._context)
        self.busy = RootLuZ_controller_exInstanceBusy(self._context)


class RootLuZ_controller_ex(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.z_controller_ex'
        self.instance = RootLuZ_controller_exInstance(self._context)


class RootLuAnalog_fast_outFast3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.busy'


class RootLuAnalog_fast_outFast3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.trigger'


class RootLuAnalog_fast_outFast3AttributeCalib_sig_source_dir(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_sig_source_dir.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeAnalog_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 1
        enabled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.analog_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast3AttributeAnalog_output.ValueEnum(self._context.get('root.lu.analog_fast_out.fast3.attribute.analog_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.analog_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast3.attribute.analog_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.analog_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast3.attribute.analog_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.analog_output.enum', list(new_val))


class RootLuAnalog_fast_outFast3AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast3AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_outFast3AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_gain.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        hi_res_signal = 3
        disabled = 1
        analyzer2_reference = 0
        damping = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast3AttributeModulation.ValueEnum(self._context.get('root.lu.analog_fast_out.fast3.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast3.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast3.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.modulation.enum', list(new_val))


class RootLuAnalog_fast_outFast3AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fast_in2 = 2
        ort_excitation = 6
        analyzer2_reference = 5
        ctrl_z_out = 8
        analyzer1_reference = 4
        in_deflection = 1
        static = 0
        ort_free_wave = 7
        ctrl_w_out = 9
        in_user = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast3AttributeInput.ValueEnum(self._context.get('root.lu.analog_fast_out.fast3.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast3.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast3.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.input.enum', list(new_val))


class RootLuAnalog_fast_outFast3AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.static_value.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeDamping_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.damping_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.damping_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.damping_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.damping_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.damping_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.damping_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.damping_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.damping_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.damping_gain.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_outFast3AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast3.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast3.attribute.output_offset.value', float(new_val))


class RootLuAnalog_fast_outFast3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3.attribute'
        self.output_offset = RootLuAnalog_fast_outFast3AttributeOutput_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_outFast3AttributeCalib_gain(self._context)
        self.damping_gain = RootLuAnalog_fast_outFast3AttributeDamping_gain(self._context)
        self.static_value = RootLuAnalog_fast_outFast3AttributeStatic_value(self._context)
        self.input = RootLuAnalog_fast_outFast3AttributeInput(self._context)
        self.modulation = RootLuAnalog_fast_outFast3AttributeModulation(self._context)
        self.calib_offset = RootLuAnalog_fast_outFast3AttributeCalib_offset(self._context)
        self.output_gain = RootLuAnalog_fast_outFast3AttributeOutput_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_outFast3AttributeCalib_polarity(self._context)
        self.current_output_value = RootLuAnalog_fast_outFast3AttributeCurrent_output_value(self._context)
        self.analog_output = RootLuAnalog_fast_outFast3AttributeAnalog_output(self._context)
        self.calib_sig_source_dir = RootLuAnalog_fast_outFast3AttributeCalib_sig_source_dir(self._context)


class RootLuAnalog_fast_outFast3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast3'
        self.attribute = RootLuAnalog_fast_outFast3Attribute(self._context)
        self.trigger = RootLuAnalog_fast_outFast3Trigger(self._context)
        self.busy = RootLuAnalog_fast_outFast3Busy(self._context)


class RootLuAnalog_fast_outExcitationBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.busy'


class RootLuAnalog_fast_outExcitationTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.trigger'


class RootLuAnalog_fast_outExcitationAttributeCalib_sig_source_dir(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_sig_source_dir.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeAnalog_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 1
        enabled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.analog_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outExcitationAttributeAnalog_output.ValueEnum(self._context.get('root.lu.analog_fast_out.excitation.attribute.analog_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.analog_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.excitation.attribute.analog_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.analog_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.excitation.attribute.analog_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.analog_output.enum', list(new_val))


class RootLuAnalog_fast_outExcitationAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outExcitationAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_outExcitationAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_gain.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        hi_res_signal = 3
        disabled = 1
        analyzer2_reference = 0
        damping = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outExcitationAttributeModulation.ValueEnum(self._context.get('root.lu.analog_fast_out.excitation.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.excitation.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.excitation.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.modulation.enum', list(new_val))


class RootLuAnalog_fast_outExcitationAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fast_in2 = 2
        ort_excitation = 6
        analyzer2_reference = 5
        ctrl_z_out = 8
        analyzer1_reference = 4
        in_deflection = 1
        static = 0
        ort_free_wave = 7
        ctrl_w_out = 9
        in_user = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outExcitationAttributeInput.ValueEnum(self._context.get('root.lu.analog_fast_out.excitation.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.excitation.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.excitation.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.input.enum', list(new_val))


class RootLuAnalog_fast_outExcitationAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.static_value.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeDamping_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.damping_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.damping_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.damping_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.damping_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.damping_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.damping_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.damping_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.damping_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.damping_gain.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.excitation.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.excitation.attribute.output_offset.value', float(new_val))


class RootLuAnalog_fast_outExcitationAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation.attribute'
        self.output_offset = RootLuAnalog_fast_outExcitationAttributeOutput_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_outExcitationAttributeCalib_gain(self._context)
        self.damping_gain = RootLuAnalog_fast_outExcitationAttributeDamping_gain(self._context)
        self.static_value = RootLuAnalog_fast_outExcitationAttributeStatic_value(self._context)
        self.input = RootLuAnalog_fast_outExcitationAttributeInput(self._context)
        self.modulation = RootLuAnalog_fast_outExcitationAttributeModulation(self._context)
        self.calib_offset = RootLuAnalog_fast_outExcitationAttributeCalib_offset(self._context)
        self.output_gain = RootLuAnalog_fast_outExcitationAttributeOutput_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_outExcitationAttributeCalib_polarity(self._context)
        self.current_output_value = RootLuAnalog_fast_outExcitationAttributeCurrent_output_value(self._context)
        self.analog_output = RootLuAnalog_fast_outExcitationAttributeAnalog_output(self._context)
        self.calib_sig_source_dir = RootLuAnalog_fast_outExcitationAttributeCalib_sig_source_dir(self._context)


class RootLuAnalog_fast_outExcitation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.excitation'
        self.attribute = RootLuAnalog_fast_outExcitationAttribute(self._context)
        self.trigger = RootLuAnalog_fast_outExcitationTrigger(self._context)
        self.busy = RootLuAnalog_fast_outExcitationBusy(self._context)


class RootLuAnalog_fast_outFast2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.busy'


class RootLuAnalog_fast_outFast2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.trigger'


class RootLuAnalog_fast_outFast2AttributeCalib_sig_source_dir(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_sig_source_dir.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeAnalog_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 1
        enabled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.analog_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast2AttributeAnalog_output.ValueEnum(self._context.get('root.lu.analog_fast_out.fast2.attribute.analog_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.analog_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast2.attribute.analog_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.analog_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast2.attribute.analog_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.analog_output.enum', list(new_val))


class RootLuAnalog_fast_outFast2AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast2AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_outFast2AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_gain.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        hi_res_signal = 3
        disabled = 1
        analyzer2_reference = 0
        damping = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast2AttributeModulation.ValueEnum(self._context.get('root.lu.analog_fast_out.fast2.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast2.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast2.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.modulation.enum', list(new_val))


class RootLuAnalog_fast_outFast2AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fast_in2 = 2
        ort_excitation = 6
        analyzer2_reference = 5
        ctrl_z_out = 8
        analyzer1_reference = 4
        in_deflection = 1
        static = 0
        ort_free_wave = 7
        ctrl_w_out = 9
        in_user = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outFast2AttributeInput.ValueEnum(self._context.get('root.lu.analog_fast_out.fast2.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.fast2.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.fast2.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.input.enum', list(new_val))


class RootLuAnalog_fast_outFast2AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.static_value.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeDamping_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.damping_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.damping_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.damping_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.damping_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.damping_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.damping_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.damping_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.damping_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.damping_gain.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_outFast2AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.fast2.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.fast2.attribute.output_offset.value', float(new_val))


class RootLuAnalog_fast_outFast2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2.attribute'
        self.output_offset = RootLuAnalog_fast_outFast2AttributeOutput_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_outFast2AttributeCalib_gain(self._context)
        self.damping_gain = RootLuAnalog_fast_outFast2AttributeDamping_gain(self._context)
        self.static_value = RootLuAnalog_fast_outFast2AttributeStatic_value(self._context)
        self.input = RootLuAnalog_fast_outFast2AttributeInput(self._context)
        self.modulation = RootLuAnalog_fast_outFast2AttributeModulation(self._context)
        self.calib_offset = RootLuAnalog_fast_outFast2AttributeCalib_offset(self._context)
        self.output_gain = RootLuAnalog_fast_outFast2AttributeOutput_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_outFast2AttributeCalib_polarity(self._context)
        self.current_output_value = RootLuAnalog_fast_outFast2AttributeCurrent_output_value(self._context)
        self.analog_output = RootLuAnalog_fast_outFast2AttributeAnalog_output(self._context)
        self.calib_sig_source_dir = RootLuAnalog_fast_outFast2AttributeCalib_sig_source_dir(self._context)


class RootLuAnalog_fast_outFast2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.fast2'
        self.attribute = RootLuAnalog_fast_outFast2Attribute(self._context)
        self.trigger = RootLuAnalog_fast_outFast2Trigger(self._context)
        self.busy = RootLuAnalog_fast_outFast2Busy(self._context)


class RootLuAnalog_fast_outUserBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.busy'


class RootLuAnalog_fast_outUserTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.trigger'


class RootLuAnalog_fast_outUserAttributeCalib_sig_source_dir(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_sig_source_dir.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeAnalog_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 1
        enabled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.analog_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outUserAttributeAnalog_output.ValueEnum(self._context.get('root.lu.analog_fast_out.user.attribute.analog_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.user.attribute.analog_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.user.attribute.analog_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.user.attribute.analog_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.user.attribute.analog_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.user.attribute.analog_output.enum', list(new_val))


class RootLuAnalog_fast_outUserAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outUserAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_out.user.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.user.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.user.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_outUserAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_gain.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        hi_res_signal = 3
        disabled = 1
        analyzer2_reference = 0
        damping = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outUserAttributeModulation.ValueEnum(self._context.get('root.lu.analog_fast_out.user.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.user.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.user.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.user.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.user.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.user.attribute.modulation.enum', list(new_val))


class RootLuAnalog_fast_outUserAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fast_in2 = 2
        ort_excitation = 6
        analyzer2_reference = 5
        ctrl_z_out = 8
        analyzer1_reference = 4
        in_deflection = 1
        static = 0
        ort_free_wave = 7
        ctrl_w_out = 9
        in_user = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_outUserAttributeInput.ValueEnum(self._context.get('root.lu.analog_fast_out.user.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_out.user.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_out.user.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_out.user.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_out.user.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_out.user.attribute.input.enum', list(new_val))


class RootLuAnalog_fast_outUserAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.static_value.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeDamping_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.damping_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.damping_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.damping_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.damping_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.damping_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.damping_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.damping_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.damping_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.damping_gain.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_outUserAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_out.user.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_out.user.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_out.user.attribute.output_offset.value', float(new_val))


class RootLuAnalog_fast_outUserAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user.attribute'
        self.output_offset = RootLuAnalog_fast_outUserAttributeOutput_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_outUserAttributeCalib_gain(self._context)
        self.damping_gain = RootLuAnalog_fast_outUserAttributeDamping_gain(self._context)
        self.static_value = RootLuAnalog_fast_outUserAttributeStatic_value(self._context)
        self.input = RootLuAnalog_fast_outUserAttributeInput(self._context)
        self.modulation = RootLuAnalog_fast_outUserAttributeModulation(self._context)
        self.calib_offset = RootLuAnalog_fast_outUserAttributeCalib_offset(self._context)
        self.output_gain = RootLuAnalog_fast_outUserAttributeOutput_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_outUserAttributeCalib_polarity(self._context)
        self.current_output_value = RootLuAnalog_fast_outUserAttributeCurrent_output_value(self._context)
        self.analog_output = RootLuAnalog_fast_outUserAttributeAnalog_output(self._context)
        self.calib_sig_source_dir = RootLuAnalog_fast_outUserAttributeCalib_sig_source_dir(self._context)


class RootLuAnalog_fast_outUser(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out.user'
        self.attribute = RootLuAnalog_fast_outUserAttribute(self._context)
        self.trigger = RootLuAnalog_fast_outUserTrigger(self._context)
        self.busy = RootLuAnalog_fast_outUserBusy(self._context)


class RootLuAnalog_fast_out(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_out'
        self.user = RootLuAnalog_fast_outUser(self._context)
        self.fast2 = RootLuAnalog_fast_outFast2(self._context)
        self.excitation = RootLuAnalog_fast_outExcitation(self._context)
        self.fast3 = RootLuAnalog_fast_outFast3(self._context)


class RootLuMainboard_relaysInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays.instance.busy'


class RootLuMainboard_relaysInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays.instance.trigger'


class RootLuMainboard_relaysInstanceAttributeSet_state_mask(wrap.CmdTreeProp):

    class ValueMask(enum.IntEnum):
        hires_out_user4 = 8
        hires_in_user4 = 128
        hires_out_user3 = 4
        hires_in_user2 = 32
        none = 0
        fast_out_user = 256
        dummy0 = 2048
        hires_in_user1 = 16
        all = 4095
        hires_out_user2 = 2
        fast_in_user = 512
        hires_out_user1 = 1
        hires_in_user3 = 64
        hi_res_in6 = 1024

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays.instance.attribute.set_state_mask'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> int:
        return int(self._context.get('root.lu.mainboard_relays.instance.attribute.set_state_mask.value_raw'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.lu.mainboard_relays.instance.attribute.set_state_mask.value_raw', int(new_val))

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.mainboard_relays.instance.attribute.set_state_mask.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.mainboard_relays.instance.attribute.set_state_mask.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.mainboard_relays.instance.attribute.set_state_mask.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.mainboard_relays.instance.attribute.set_state_mask.enum', list(new_val))


class RootLuMainboard_relaysInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays.instance.attribute'
        self.set_state_mask = RootLuMainboard_relaysInstanceAttributeSet_state_mask(self._context)


class RootLuMainboard_relaysInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays.instance'
        self.attribute = RootLuMainboard_relaysInstanceAttribute(self._context)
        self.trigger = RootLuMainboard_relaysInstanceTrigger(self._context)
        self.busy = RootLuMainboard_relaysInstanceBusy(self._context)


class RootLuMainboard_relays(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.mainboard_relays'
        self.instance = RootLuMainboard_relaysInstance(self._context)


class RootLuAnalog_hi_res_outUser3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.busy'


class RootLuAnalog_hi_res_outUser3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.trigger'


class RootLuAnalog_hi_res_outUser3AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser3AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user3.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser3AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser3AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user3.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outUser3AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outUser3AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outUser3AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outUser3AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outUser3AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outUser3AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outUser3AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outUser3AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outUser3AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outUser3AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outUser3AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outUser3AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outUser3AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outUser3AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outUser3AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outUser3AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outUser3AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outUser3AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outUser3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user3'
        self.attribute = RootLuAnalog_hi_res_outUser3Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outUser3Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outUser3Busy(self._context)


class RootLuAnalog_hi_res_outUser1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.busy'


class RootLuAnalog_hi_res_outUser1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.trigger'


class RootLuAnalog_hi_res_outUser1AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser1AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user1.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser1AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser1AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user1.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outUser1AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outUser1AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outUser1AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outUser1AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outUser1AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outUser1AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outUser1AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outUser1AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outUser1AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outUser1AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outUser1AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outUser1AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outUser1AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outUser1AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outUser1AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outUser1AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outUser1AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outUser1AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outUser1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user1'
        self.attribute = RootLuAnalog_hi_res_outUser1Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outUser1Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outUser1Busy(self._context)


class RootLuAnalog_hi_res_outUser4Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.busy'


class RootLuAnalog_hi_res_outUser4Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.trigger'


class RootLuAnalog_hi_res_outUser4AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser4AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user4.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser4AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser4AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user4.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser4Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outUser4AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outUser4AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outUser4AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outUser4AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outUser4AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outUser4AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outUser4AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outUser4AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outUser4AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outUser4AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outUser4AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outUser4AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outUser4AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outUser4AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outUser4AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outUser4AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outUser4AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outUser4AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outUser4(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user4'
        self.attribute = RootLuAnalog_hi_res_outUser4Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outUser4Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outUser4Busy(self._context)


class RootLuAnalog_hi_res_outUser2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.busy'


class RootLuAnalog_hi_res_outUser2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.trigger'


class RootLuAnalog_hi_res_outUser2AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outUser2AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.user2.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outUser2AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outUser2AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.user2.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outUser2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outUser2AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outUser2AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outUser2AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outUser2AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outUser2AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outUser2AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outUser2AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outUser2AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outUser2AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outUser2AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outUser2AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outUser2AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outUser2AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outUser2AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outUser2AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outUser2AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outUser2AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outUser2AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outUser2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.user2'
        self.attribute = RootLuAnalog_hi_res_outUser2Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outUser2Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outUser2Busy(self._context)


class RootLuAnalog_hi_res_outOut7Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.busy'


class RootLuAnalog_hi_res_outOut7Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.trigger'


class RootLuAnalog_hi_res_outOut7AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut7AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out7.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outOut7AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outOut7AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out7.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut7Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outOut7AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outOut7AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outOut7AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outOut7AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outOut7AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outOut7AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outOut7AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outOut7AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outOut7AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outOut7AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outOut7AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outOut7AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outOut7AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outOut7AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outOut7AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outOut7AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outOut7AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outOut7AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outOut7(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out7'
        self.attribute = RootLuAnalog_hi_res_outOut7Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outOut7Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outOut7Busy(self._context)


class RootLuAnalog_hi_res_outTip_voltageBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.busy'


class RootLuAnalog_hi_res_outTip_voltageTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.trigger'


class RootLuAnalog_hi_res_outTip_voltageAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outTip_voltageAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.tip_voltage.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outTip_voltageAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outTip_voltageAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outTip_voltageAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outTip_voltageAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outTip_voltageAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outTip_voltageAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outTip_voltageAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outTip_voltageAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outTip_voltageAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outTip_voltageAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outTip_voltageAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outTip_voltageAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outTip_voltageAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outTip_voltageAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outTip_voltage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.tip_voltage'
        self.attribute = RootLuAnalog_hi_res_outTip_voltageAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outTip_voltageTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outTip_voltageBusy(self._context)


class RootLuAnalog_hi_res_outPosition_xBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.busy'


class RootLuAnalog_hi_res_outPosition_xTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.trigger'


class RootLuAnalog_hi_res_outPosition_xAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_xAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_x.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_xAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outPosition_xAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outPosition_xAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outPosition_xAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outPosition_xAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outPosition_xAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outPosition_xAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outPosition_xAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outPosition_xAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outPosition_xAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outPosition_xAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outPosition_xAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outPosition_xAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outPosition_xAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outPosition_xAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outPosition_xAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outPosition_xAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outPosition_xAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outPosition_xAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outPosition_x(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_x'
        self.attribute = RootLuAnalog_hi_res_outPosition_xAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outPosition_xTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outPosition_xBusy(self._context)


class RootLuAnalog_hi_res_outPosition_yBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.busy'


class RootLuAnalog_hi_res_outPosition_yTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.trigger'


class RootLuAnalog_hi_res_outPosition_yAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_yAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_y.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_yAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outPosition_yAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outPosition_yAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outPosition_yAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outPosition_yAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outPosition_yAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outPosition_yAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outPosition_yAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outPosition_yAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outPosition_yAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outPosition_yAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outPosition_yAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outPosition_yAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outPosition_yAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outPosition_yAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outPosition_yAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outPosition_yAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outPosition_yAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outPosition_yAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outPosition_y(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_y'
        self.attribute = RootLuAnalog_hi_res_outPosition_yAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outPosition_yTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outPosition_yBusy(self._context)


class RootLuAnalog_hi_res_outApproachBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.busy'


class RootLuAnalog_hi_res_outApproachTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.trigger'


class RootLuAnalog_hi_res_outApproachAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outApproachAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.approach.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outApproachAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.approach.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outApproachAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outApproachAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outApproachAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outApproachAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outApproachAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outApproachAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outApproachAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outApproachAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outApproachAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outApproachAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outApproachAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outApproachAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outApproachAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outApproachAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outApproachAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outApproachAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outApproachAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outApproachAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outApproachAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.approach'
        self.attribute = RootLuAnalog_hi_res_outApproachAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outApproachTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outApproachBusy(self._context)


class RootLuAnalog_hi_res_outOut8Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.busy'


class RootLuAnalog_hi_res_outOut8Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.trigger'


class RootLuAnalog_hi_res_outOut8AttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outOut8AttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.out8.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outOut8AttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outOut8AttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.out8.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outOut8Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outOut8AttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outOut8AttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outOut8AttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outOut8AttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outOut8AttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outOut8AttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outOut8AttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outOut8AttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outOut8AttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outOut8AttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outOut8AttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outOut8AttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outOut8AttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outOut8AttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outOut8AttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outOut8AttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outOut8AttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outOut8AttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outOut8(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.out8'
        self.attribute = RootLuAnalog_hi_res_outOut8Attribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outOut8Trigger(self._context)
        self.busy = RootLuAnalog_hi_res_outOut8Busy(self._context)


class RootLuAnalog_hi_res_outPosition_zBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.busy'


class RootLuAnalog_hi_res_outPosition_zTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.trigger'


class RootLuAnalog_hi_res_outPosition_zAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_zAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_z.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_zAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outPosition_zAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outPosition_zAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outPosition_zAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outPosition_zAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outPosition_zAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outPosition_zAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outPosition_zAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outPosition_zAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outPosition_zAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outPosition_zAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outPosition_zAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outPosition_zAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outPosition_zAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outPosition_zAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outPosition_zAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outPosition_zAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outPosition_zAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outPosition_zAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outPosition_z(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_z'
        self.attribute = RootLuAnalog_hi_res_outPosition_zAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outPosition_zTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outPosition_zBusy(self._context)


class RootLuAnalog_hi_res_outPosition_wBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.busy'


class RootLuAnalog_hi_res_outPosition_wTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.trigger'


class RootLuAnalog_hi_res_outPosition_wAttributeCurrent_output_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.current_output_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.current_output_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_sig_source_dir(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        from_input_to_output = 1
        from_output_to_input = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeCalib_sig_source_dir.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_sig_source_dir.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeInput.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeSlew_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.slew_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.slew_rate.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeGlitch_corr_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_binary_vec.vector', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeOutput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.output_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeModulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        ort_excitation = 2
        hi_res_signal = 3
        analyzer2_reference = 0
        disabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeModulation.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeGlitch_corr_enabled(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeGlitch_corr_enabled.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.glitch_corr_enabled.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_lo_word_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_delay.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeStatic_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.static_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.static_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.static_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.static_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.static_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.static_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.static_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.static_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.static_value.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeModulation_input(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 21
        ctrl_z_sum = 26
        ctrl_user1_out = 32
        analyzer1_ctrl_delta_f = 34
        ort_baseline = 46
        analyzer1_y = 39
        analyzer2_phase = 42
        analyzer1_reference = 63
        ctrl_z_pid_command = 25
        analyzer2_ctrl_delta_f = 40
        analyzer2_x = 44
        analyzer1_phase = 36
        in_position_y = 6
        ctrl_user2_out = 33
        ramp_gen_alternate_z = 19
        in_detector_sum = 13
        ramp_gen_test = 2
        ramp_gen_approach = 15
        ctrl_z_nominal = 27
        in_position_x = 5
        analyzer2_amplitude = 43
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 17
        analyzer2_y = 45
        ctrl_y_out = 30
        static = 0
        analyzer1_ctrl_amplitude = 35
        ramp_gen_max_z = 22
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 14
        analyzer2_ctrl_amplitude = 41
        in_user3 = 10
        ctrl_z_out = 28
        memory_gen_position_y = 53
        in_tip_current = 12
        ort_amplitude_reduction = 48
        analyzer1_x = 38
        in_user4 = 11
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 18
        ramp_gen_position_x = 16
        ramp_gen_plane_z = 20
        in_deflection = 3
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 4
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 9
        in_user1 = 8
        in_position_z = 7
        analyzer2_reference = 64
        analyzer1_amplitude = 37
        ort_adhesion_position = 50
        gen_test_dynamic = 1
        ctrl_z_error = 24
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 23
        ctrl_x_out = 29
        ctrl_w_out = 31

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.modulation_input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_hi_res_outPosition_wAttributeModulation_input.ValueEnum(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.modulation_input.enum', list(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeFilter_number(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.filter_number'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_number.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_number.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_number.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_number.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_number.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_number.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.filter_number.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.filter_number.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeOutput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.output_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.output_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.output_offset.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttributeCalib_lo_word_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_hi_res_out.position_w.attribute.calib_lo_word_gain.value', float(new_val))


class RootLuAnalog_hi_res_outPosition_wAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w.attribute'
        self.calib_lo_word_gain = RootLuAnalog_hi_res_outPosition_wAttributeCalib_lo_word_gain(self._context)
        self.output_offset = RootLuAnalog_hi_res_outPosition_wAttributeOutput_offset(self._context)
        self.filter_number = RootLuAnalog_hi_res_outPosition_wAttributeFilter_number(self._context)
        self.modulation_input = RootLuAnalog_hi_res_outPosition_wAttributeModulation_input(self._context)
        self.calib_offset = RootLuAnalog_hi_res_outPosition_wAttributeCalib_offset(self._context)
        self.static_value = RootLuAnalog_hi_res_outPosition_wAttributeStatic_value(self._context)
        self.calib_polarity = RootLuAnalog_hi_res_outPosition_wAttributeCalib_polarity(self._context)
        self.calib_lo_word_delay = RootLuAnalog_hi_res_outPosition_wAttributeCalib_lo_word_delay(self._context)
        self.calib_gain = RootLuAnalog_hi_res_outPosition_wAttributeCalib_gain(self._context)
        self.glitch_corr_enabled = RootLuAnalog_hi_res_outPosition_wAttributeGlitch_corr_enabled(self._context)
        self.modulation = RootLuAnalog_hi_res_outPosition_wAttributeModulation(self._context)
        self.output_gain = RootLuAnalog_hi_res_outPosition_wAttributeOutput_gain(self._context)
        self.glitch_corr_binary_vec = RootLuAnalog_hi_res_outPosition_wAttributeGlitch_corr_binary_vec(self._context)
        self.filter_coeff_vec = RootLuAnalog_hi_res_outPosition_wAttributeFilter_coeff_vec(self._context)
        self.slew_rate = RootLuAnalog_hi_res_outPosition_wAttributeSlew_rate(self._context)
        self.input = RootLuAnalog_hi_res_outPosition_wAttributeInput(self._context)
        self.calib_sig_source_dir = RootLuAnalog_hi_res_outPosition_wAttributeCalib_sig_source_dir(self._context)
        self.current_output_value = RootLuAnalog_hi_res_outPosition_wAttributeCurrent_output_value(self._context)


class RootLuAnalog_hi_res_outPosition_w(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out.position_w'
        self.attribute = RootLuAnalog_hi_res_outPosition_wAttribute(self._context)
        self.trigger = RootLuAnalog_hi_res_outPosition_wTrigger(self._context)
        self.busy = RootLuAnalog_hi_res_outPosition_wBusy(self._context)


class RootLuAnalog_hi_res_out(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_hi_res_out'
        self.position_w = RootLuAnalog_hi_res_outPosition_w(self._context)
        self.position_z = RootLuAnalog_hi_res_outPosition_z(self._context)
        self.out8 = RootLuAnalog_hi_res_outOut8(self._context)
        self.approach = RootLuAnalog_hi_res_outApproach(self._context)
        self.position_y = RootLuAnalog_hi_res_outPosition_y(self._context)
        self.position_x = RootLuAnalog_hi_res_outPosition_x(self._context)
        self.tip_voltage = RootLuAnalog_hi_res_outTip_voltage(self._context)
        self.out7 = RootLuAnalog_hi_res_outOut7(self._context)
        self.user2 = RootLuAnalog_hi_res_outUser2(self._context)
        self.user4 = RootLuAnalog_hi_res_outUser4(self._context)
        self.user1 = RootLuAnalog_hi_res_outUser1(self._context)
        self.user3 = RootLuAnalog_hi_res_outUser3(self._context)


class RootLuCantilever_propertiesInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.busy'


class RootLuCantilever_propertiesInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.trigger'


class RootLuCantilever_propertiesInstanceAttributeWidth(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.width'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.width.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.width.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.width.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.width.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.width.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.width.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.width.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.width.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeTip_half_angle(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.tip_half_angle'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_half_angle.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_half_angle.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_half_angle.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_half_angle.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_half_angle.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_half_angle.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_half_angle.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_half_angle.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeAlign_strategy(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        search_for_reflecting_edges = 1
        standard = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.align_strategy'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuCantilever_propertiesInstanceAttributeAlign_strategy.ValueEnum(self._context.get('root.lu.cantilever_properties.instance.attribute.align_strategy.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.cantilever_properties.instance.attribute.align_strategy.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.cantilever_properties.instance.attribute.align_strategy.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.cantilever_properties.instance.attribute.align_strategy.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.cantilever_properties.instance.attribute.align_strategy.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.cantilever_properties.instance.attribute.align_strategy.enum', list(new_val))


class RootLuCantilever_propertiesInstanceAttributeDeflection_sensitivity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.deflection_sensitivity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.deflection_sensitivity.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeLength(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.length'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.length.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.length.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.length.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.length.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.length.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.length.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.length.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.length.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeShape(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        rectangular = 0
        triangular = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.shape'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuCantilever_propertiesInstanceAttributeShape.ValueEnum(self._context.get('root.lu.cantilever_properties.instance.attribute.shape.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.cantilever_properties.instance.attribute.shape.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.cantilever_properties.instance.attribute.shape.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.cantilever_properties.instance.attribute.shape.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.cantilever_properties.instance.attribute.shape.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.cantilever_properties.instance.attribute.shape.enum', list(new_val))


class RootLuCantilever_propertiesInstanceAttributeTip_radius(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.tip_radius'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_radius.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_radius.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_radius.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_radius.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_radius.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_radius.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.tip_radius.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.tip_radius.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeQ_factor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.q_factor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.q_factor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.q_factor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.q_factor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.q_factor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.q_factor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.q_factor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.q_factor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.q_factor.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeResonance_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.resonance_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.resonance_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.resonance_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.resonance_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.resonance_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.resonance_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.resonance_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.resonance_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.resonance_frequency.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttributeSpring_constant(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute.spring_constant'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.spring_constant.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.spring_constant.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.spring_constant.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.spring_constant.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.cantilever_properties.instance.attribute.spring_constant.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.cantilever_properties.instance.attribute.spring_constant.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.cantilever_properties.instance.attribute.spring_constant.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.cantilever_properties.instance.attribute.spring_constant.value', float(new_val))


class RootLuCantilever_propertiesInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance.attribute'
        self.spring_constant = RootLuCantilever_propertiesInstanceAttributeSpring_constant(self._context)
        self.resonance_frequency = RootLuCantilever_propertiesInstanceAttributeResonance_frequency(self._context)
        self.q_factor = RootLuCantilever_propertiesInstanceAttributeQ_factor(self._context)
        self.tip_radius = RootLuCantilever_propertiesInstanceAttributeTip_radius(self._context)
        self.shape = RootLuCantilever_propertiesInstanceAttributeShape(self._context)
        self.length = RootLuCantilever_propertiesInstanceAttributeLength(self._context)
        self.deflection_sensitivity = RootLuCantilever_propertiesInstanceAttributeDeflection_sensitivity(self._context)
        self.align_strategy = RootLuCantilever_propertiesInstanceAttributeAlign_strategy(self._context)
        self.tip_half_angle = RootLuCantilever_propertiesInstanceAttributeTip_half_angle(self._context)
        self.width = RootLuCantilever_propertiesInstanceAttributeWidth(self._context)


class RootLuCantilever_propertiesInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties.instance'
        self.attribute = RootLuCantilever_propertiesInstanceAttribute(self._context)
        self.trigger = RootLuCantilever_propertiesInstanceTrigger(self._context)
        self.busy = RootLuCantilever_propertiesInstanceBusy(self._context)


class RootLuCantilever_properties(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.cantilever_properties'
        self.instance = RootLuCantilever_propertiesInstance(self._context)


class RootLuSensor_controlInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.busy'


class RootLuSensor_controlInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.trigger'

    def deflection_offset_calibration_with_retract(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.deflection_offset_calibration_with_retract')

    def update_laser_spot_on_detector_status(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.update_laser_spot_on_detector_status')

    def deflection_offset_calibration(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.deflection_offset_calibration')

    def start_set_dynamic_amplitude(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.start_set_dynamic_amplitude')

    def start_sensor_calibration(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.start_sensor_calibration')

    def user_abort(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.user_abort')

    def start_deflection_offset_calibration(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.start_deflection_offset_calibration')

    def start_detector_auto_adjustment(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.start_detector_auto_adjustment')

    def start_update_laser_spot_on_detector_status(self) -> None:
        return self._context.call('root.lu.sensor_control.instance.trigger.start_update_laser_spot_on_detector_status')


class RootLuSensor_controlInstanceAttributeDetector_adjustment_duration_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_duration_limit.value', float(new_val))


class RootLuSensor_controlInstanceAttributeDeflection_offset_calibration_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        calibration_error = 1
        sensor_signal_failed = 2
        no_error = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSensor_controlInstanceAttributeDeflection_offset_calibration_status.ValueEnum(self._context.get('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.sensor_control.instance.attribute.deflection_offset_calibration_status.enum', list(new_val))


class RootLuSensor_controlInstanceAttributeSensor_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.sensor_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.sensor_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.sensor_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.sensor_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.sensor_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sensor_control.instance.attribute.sensor_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sensor_control.instance.attribute.sensor_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.sensor_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.sensor_amplitude.value', float(new_val))


class RootLuSensor_controlInstanceAttributeEnable10_hz_update_laser_spot_on_detector_status(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.enable10_hz_update_laser_spot_on_detector_status.value', float(new_val))


class RootLuSensor_controlInstanceAttributeOffset_calib_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_auto_calibration = 0
        auto_calibrate_z_ctrl_input = 2
        auto_calibrate_deflection = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.offset_calib_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSensor_controlInstanceAttributeOffset_calib_mode.ValueEnum(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_mode.enum', list(new_val))


class RootLuSensor_controlInstanceAttributeOffset_calib_i_gain_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        fix_from_attr = 0
        auto_from_head_typ = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSensor_controlInstanceAttributeOffset_calib_i_gain_mode.ValueEnum(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain_mode.enum', list(new_val))


class RootLuSensor_controlInstanceAttributeOffset_calib_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.offset_calib_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.offset_calib_i_gain.value', float(new_val))


class RootLuSensor_controlInstanceAttributeDetector_adjustment_tolerance(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_adjustment_tolerance.value', float(new_val))


class RootLuSensor_controlInstanceAttributeDetector_auto_adjustment_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        failed = 2
        running = 1
        idle = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSensor_controlInstanceAttributeDetector_auto_adjustment_status.ValueEnum(self._context.get('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.sensor_control.instance.attribute.detector_auto_adjustment_status.enum', list(new_val))


class RootLuSensor_controlInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance.attribute'
        self.detector_auto_adjustment_status = RootLuSensor_controlInstanceAttributeDetector_auto_adjustment_status(self._context)
        self.detector_adjustment_tolerance = RootLuSensor_controlInstanceAttributeDetector_adjustment_tolerance(self._context)
        self.offset_calib_i_gain = RootLuSensor_controlInstanceAttributeOffset_calib_i_gain(self._context)
        self.offset_calib_i_gain_mode = RootLuSensor_controlInstanceAttributeOffset_calib_i_gain_mode(self._context)
        self.offset_calib_mode = RootLuSensor_controlInstanceAttributeOffset_calib_mode(self._context)
        self.enable10_hz_update_laser_spot_on_detector_status = RootLuSensor_controlInstanceAttributeEnable10_hz_update_laser_spot_on_detector_status(self._context)
        self.sensor_amplitude = RootLuSensor_controlInstanceAttributeSensor_amplitude(self._context)
        self.deflection_offset_calibration_status = RootLuSensor_controlInstanceAttributeDeflection_offset_calibration_status(self._context)
        self.detector_adjustment_duration_limit = RootLuSensor_controlInstanceAttributeDetector_adjustment_duration_limit(self._context)


class RootLuSensor_controlInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control.instance'
        self.attribute = RootLuSensor_controlInstanceAttribute(self._context)
        self.trigger = RootLuSensor_controlInstanceTrigger(self._context)
        self.busy = RootLuSensor_controlInstanceBusy(self._context)


class RootLuSensor_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.sensor_control'
        self.instance = RootLuSensor_controlInstance(self._context)


class RootLuPid_controllerPid_yBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.busy'


class RootLuPid_controllerPid_yTriggerDrive_to_zero_volt_position(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.trigger.drive_to_zero_volt_position'


class RootLuPid_controllerPid_yTriggerCalibrate_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.trigger.calibrate_offset'


class RootLuPid_controllerPid_yTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.trigger'
        self.calibrate_offset = RootLuPid_controllerPid_yTriggerCalibrate_offset(self._context)
        self.drive_to_zero_volt_position = RootLuPid_controllerPid_yTriggerDrive_to_zero_volt_position(self._context)

    def clear_pid_accu(self) -> None:
        return self._context.call('root.lu.pid_controller.pid_y.trigger.clear_pid_accu')


class RootLuPid_controllerPid_yAttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuPid_controllerPid_yAttributeP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.p_gain.value', float(new_val))


class RootLuPid_controllerPid_yAttributeReached_min(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.reached_min'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_min.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_min.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_min.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_min.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_min.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_min.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_min.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_min.value', float(new_val))


class RootLuPid_controllerPid_yAttributeI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.i_gain.value', float(new_val))


class RootLuPid_controllerPid_yAttributeSlope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.slope.value', float(new_val))


class RootLuPid_controllerPid_yAttributeSet_point_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.set_point_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_gain.value', float(new_val))


class RootLuPid_controllerPid_yAttributeD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.d_gain.value', float(new_val))


class RootLuPid_controllerPid_yAttributeInput_set_point(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.input_set_point'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeInput_set_point.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.input_set_point.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_set_point.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.input_set_point.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_set_point.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.input_set_point.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_set_point.enum', list(new_val))


class RootLuPid_controllerPid_yAttributeMax_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.max_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.max_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.max_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.max_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.max_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.max_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.max_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.max_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.max_value.value', float(new_val))


class RootLuPid_controllerPid_yAttributeCompare_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.compare_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.compare_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.compare_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.compare_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.compare_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.compare_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.compare_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.compare_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.compare_mode.value', float(new_val))


class RootLuPid_controllerPid_yAttributeSelect_output(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.select_output'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.select_output.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.select_output.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.select_output.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.select_output.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.select_output.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.select_output.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.select_output.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.select_output.value', float(new_val))


class RootLuPid_controllerPid_yAttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuPid_controllerPid_yAttributeMedian_filter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.median_filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeMedian_filter_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.median_filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.median_filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.median_filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.median_filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.median_filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.median_filter_enable.enum', list(new_val))


class RootLuPid_controllerPid_yAttributePolarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.polarity.value', float(new_val))


class RootLuPid_controllerPid_yAttributeInput_actual(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.input_actual'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeInput_actual.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.input_actual.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_actual.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.input_actual.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_actual.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.input_actual.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.input_actual.enum', list(new_val))


class RootLuPid_controllerPid_yAttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_yAttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_y.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuPid_controllerPid_yAttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.min_value.value', float(new_val))


class RootLuPid_controllerPid_yAttributeOffset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.offset.value', float(new_val))


class RootLuPid_controllerPid_yAttributeError_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.error_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.error_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.error_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.error_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.error_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.error_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.error_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.error_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.error_limit.value', float(new_val))


class RootLuPid_controllerPid_yAttributeFeedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.feedback_mode.value', float(new_val))


class RootLuPid_controllerPid_yAttributeReached_err_lim(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.reached_err_lim'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_err_lim.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_err_lim.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_err_lim.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_err_lim.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_err_lim.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_err_lim.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_err_lim.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_err_lim.value', float(new_val))


class RootLuPid_controllerPid_yAttributeReached_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute.reached_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_y.attribute.reached_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_y.attribute.reached_max.value', float(new_val))


class RootLuPid_controllerPid_yAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y.attribute'
        self.reached_max = RootLuPid_controllerPid_yAttributeReached_max(self._context)
        self.reached_err_lim = RootLuPid_controllerPid_yAttributeReached_err_lim(self._context)
        self.feedback_mode = RootLuPid_controllerPid_yAttributeFeedback_mode(self._context)
        self.error_limit = RootLuPid_controllerPid_yAttributeError_limit(self._context)
        self.offset = RootLuPid_controllerPid_yAttributeOffset(self._context)
        self.min_value = RootLuPid_controllerPid_yAttributeMin_value(self._context)
        self.set_point_modulation_enable = RootLuPid_controllerPid_yAttributeSet_point_modulation_enable(self._context)
        self.input_actual = RootLuPid_controllerPid_yAttributeInput_actual(self._context)
        self.polarity = RootLuPid_controllerPid_yAttributePolarity(self._context)
        self.median_filter_enable = RootLuPid_controllerPid_yAttributeMedian_filter_enable(self._context)
        self.memory_signal_gen_drive_enable = RootLuPid_controllerPid_yAttributeMemory_signal_gen_drive_enable(self._context)
        self.select_output = RootLuPid_controllerPid_yAttributeSelect_output(self._context)
        self.compare_mode = RootLuPid_controllerPid_yAttributeCompare_mode(self._context)
        self.max_value = RootLuPid_controllerPid_yAttributeMax_value(self._context)
        self.input_set_point = RootLuPid_controllerPid_yAttributeInput_set_point(self._context)
        self.d_gain = RootLuPid_controllerPid_yAttributeD_gain(self._context)
        self.set_point_gain = RootLuPid_controllerPid_yAttributeSet_point_gain(self._context)
        self.slope = RootLuPid_controllerPid_yAttributeSlope(self._context)
        self.i_gain = RootLuPid_controllerPid_yAttributeI_gain(self._context)
        self.reached_min = RootLuPid_controllerPid_yAttributeReached_min(self._context)
        self.p_gain = RootLuPid_controllerPid_yAttributeP_gain(self._context)
        self.memory_signal_gen_position_enable = RootLuPid_controllerPid_yAttributeMemory_signal_gen_position_enable(self._context)


class RootLuPid_controllerPid_y(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_y'
        self.attribute = RootLuPid_controllerPid_yAttribute(self._context)
        self.trigger = RootLuPid_controllerPid_yTrigger(self._context)
        self.busy = RootLuPid_controllerPid_yBusy(self._context)


class RootLuPid_controllerPid_user1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.busy'


class RootLuPid_controllerPid_user1TriggerDrive_to_zero_volt_position(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.trigger.drive_to_zero_volt_position'


class RootLuPid_controllerPid_user1TriggerCalibrate_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.trigger.calibrate_offset'


class RootLuPid_controllerPid_user1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.trigger'
        self.calibrate_offset = RootLuPid_controllerPid_user1TriggerCalibrate_offset(self._context)
        self.drive_to_zero_volt_position = RootLuPid_controllerPid_user1TriggerDrive_to_zero_volt_position(self._context)

    def clear_pid_accu(self) -> None:
        return self._context.call('root.lu.pid_controller.pid_user1.trigger.clear_pid_accu')


class RootLuPid_controllerPid_user1AttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributeP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.p_gain.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeReached_min(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.reached_min'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_min.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_min.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_min.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_min.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_min.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_min.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_min.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_min.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.i_gain.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeSlope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.slope.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeSet_point_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.set_point_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_gain.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.d_gain.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeInput_set_point(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.input_set_point'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeInput_set_point.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_set_point.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_set_point.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_set_point.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_set_point.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_set_point.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_set_point.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributeMax_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.max_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.max_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.max_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.max_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.max_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.max_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.max_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.max_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.max_value.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeCompare_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.compare_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.compare_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.compare_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.compare_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.compare_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.compare_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.compare_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.compare_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.compare_mode.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeSelect_output(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.select_output'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.select_output.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.select_output.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.select_output.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.select_output.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.select_output.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.select_output.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.select_output.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.select_output.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributeMedian_filter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.median_filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeMedian_filter_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.median_filter_enable.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributePolarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.polarity.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeInput_actual(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.input_actual'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeInput_actual.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_actual.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_actual.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_actual.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_actual.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.input_actual.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.input_actual.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user1AttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuPid_controllerPid_user1AttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.min_value.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeOffset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.offset.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeError_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.error_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.error_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.error_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.error_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.error_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.error_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.error_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.error_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.error_limit.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeFeedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.feedback_mode.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeReached_err_lim(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.reached_err_lim'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_err_lim.value', float(new_val))


class RootLuPid_controllerPid_user1AttributeReached_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute.reached_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user1.attribute.reached_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user1.attribute.reached_max.value', float(new_val))


class RootLuPid_controllerPid_user1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1.attribute'
        self.reached_max = RootLuPid_controllerPid_user1AttributeReached_max(self._context)
        self.reached_err_lim = RootLuPid_controllerPid_user1AttributeReached_err_lim(self._context)
        self.feedback_mode = RootLuPid_controllerPid_user1AttributeFeedback_mode(self._context)
        self.error_limit = RootLuPid_controllerPid_user1AttributeError_limit(self._context)
        self.offset = RootLuPid_controllerPid_user1AttributeOffset(self._context)
        self.min_value = RootLuPid_controllerPid_user1AttributeMin_value(self._context)
        self.set_point_modulation_enable = RootLuPid_controllerPid_user1AttributeSet_point_modulation_enable(self._context)
        self.input_actual = RootLuPid_controllerPid_user1AttributeInput_actual(self._context)
        self.polarity = RootLuPid_controllerPid_user1AttributePolarity(self._context)
        self.median_filter_enable = RootLuPid_controllerPid_user1AttributeMedian_filter_enable(self._context)
        self.memory_signal_gen_drive_enable = RootLuPid_controllerPid_user1AttributeMemory_signal_gen_drive_enable(self._context)
        self.select_output = RootLuPid_controllerPid_user1AttributeSelect_output(self._context)
        self.compare_mode = RootLuPid_controllerPid_user1AttributeCompare_mode(self._context)
        self.max_value = RootLuPid_controllerPid_user1AttributeMax_value(self._context)
        self.input_set_point = RootLuPid_controllerPid_user1AttributeInput_set_point(self._context)
        self.d_gain = RootLuPid_controllerPid_user1AttributeD_gain(self._context)
        self.set_point_gain = RootLuPid_controllerPid_user1AttributeSet_point_gain(self._context)
        self.slope = RootLuPid_controllerPid_user1AttributeSlope(self._context)
        self.i_gain = RootLuPid_controllerPid_user1AttributeI_gain(self._context)
        self.reached_min = RootLuPid_controllerPid_user1AttributeReached_min(self._context)
        self.p_gain = RootLuPid_controllerPid_user1AttributeP_gain(self._context)
        self.memory_signal_gen_position_enable = RootLuPid_controllerPid_user1AttributeMemory_signal_gen_position_enable(self._context)


class RootLuPid_controllerPid_user1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user1'
        self.attribute = RootLuPid_controllerPid_user1Attribute(self._context)
        self.trigger = RootLuPid_controllerPid_user1Trigger(self._context)
        self.busy = RootLuPid_controllerPid_user1Busy(self._context)


class RootLuPid_controllerPid_wBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.busy'


class RootLuPid_controllerPid_wTriggerDrive_to_zero_volt_position(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.trigger.drive_to_zero_volt_position'


class RootLuPid_controllerPid_wTriggerCalibrate_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.trigger.calibrate_offset'


class RootLuPid_controllerPid_wTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.trigger'
        self.calibrate_offset = RootLuPid_controllerPid_wTriggerCalibrate_offset(self._context)
        self.drive_to_zero_volt_position = RootLuPid_controllerPid_wTriggerDrive_to_zero_volt_position(self._context)

    def clear_pid_accu(self) -> None:
        return self._context.call('root.lu.pid_controller.pid_w.trigger.clear_pid_accu')


class RootLuPid_controllerPid_wAttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuPid_controllerPid_wAttributeP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.p_gain.value', float(new_val))


class RootLuPid_controllerPid_wAttributeReached_min(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.reached_min'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_min.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_min.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_min.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_min.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_min.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_min.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_min.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_min.value', float(new_val))


class RootLuPid_controllerPid_wAttributeI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.i_gain.value', float(new_val))


class RootLuPid_controllerPid_wAttributeSlope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.slope.value', float(new_val))


class RootLuPid_controllerPid_wAttributeSet_point_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.set_point_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_gain.value', float(new_val))


class RootLuPid_controllerPid_wAttributeD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.d_gain.value', float(new_val))


class RootLuPid_controllerPid_wAttributeInput_set_point(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.input_set_point'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeInput_set_point.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.input_set_point.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_set_point.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.input_set_point.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_set_point.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.input_set_point.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_set_point.enum', list(new_val))


class RootLuPid_controllerPid_wAttributeMax_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.max_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.max_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.max_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.max_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.max_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.max_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.max_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.max_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.max_value.value', float(new_val))


class RootLuPid_controllerPid_wAttributeCompare_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.compare_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.compare_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.compare_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.compare_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.compare_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.compare_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.compare_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.compare_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.compare_mode.value', float(new_val))


class RootLuPid_controllerPid_wAttributeSelect_output(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.select_output'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.select_output.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.select_output.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.select_output.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.select_output.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.select_output.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.select_output.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.select_output.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.select_output.value', float(new_val))


class RootLuPid_controllerPid_wAttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuPid_controllerPid_wAttributeMedian_filter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.median_filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeMedian_filter_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.median_filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.median_filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.median_filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.median_filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.median_filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.median_filter_enable.enum', list(new_val))


class RootLuPid_controllerPid_wAttributePolarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.polarity.value', float(new_val))


class RootLuPid_controllerPid_wAttributeInput_actual(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.input_actual'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeInput_actual.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.input_actual.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_actual.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.input_actual.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_actual.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.input_actual.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.input_actual.enum', list(new_val))


class RootLuPid_controllerPid_wAttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_wAttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_w.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuPid_controllerPid_wAttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.min_value.value', float(new_val))


class RootLuPid_controllerPid_wAttributeOffset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.offset.value', float(new_val))


class RootLuPid_controllerPid_wAttributeError_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.error_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.error_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.error_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.error_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.error_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.error_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.error_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.error_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.error_limit.value', float(new_val))


class RootLuPid_controllerPid_wAttributeFeedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.feedback_mode.value', float(new_val))


class RootLuPid_controllerPid_wAttributeReached_err_lim(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.reached_err_lim'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_err_lim.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_err_lim.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_err_lim.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_err_lim.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_err_lim.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_err_lim.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_err_lim.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_err_lim.value', float(new_val))


class RootLuPid_controllerPid_wAttributeReached_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute.reached_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_w.attribute.reached_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_w.attribute.reached_max.value', float(new_val))


class RootLuPid_controllerPid_wAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w.attribute'
        self.reached_max = RootLuPid_controllerPid_wAttributeReached_max(self._context)
        self.reached_err_lim = RootLuPid_controllerPid_wAttributeReached_err_lim(self._context)
        self.feedback_mode = RootLuPid_controllerPid_wAttributeFeedback_mode(self._context)
        self.error_limit = RootLuPid_controllerPid_wAttributeError_limit(self._context)
        self.offset = RootLuPid_controllerPid_wAttributeOffset(self._context)
        self.min_value = RootLuPid_controllerPid_wAttributeMin_value(self._context)
        self.set_point_modulation_enable = RootLuPid_controllerPid_wAttributeSet_point_modulation_enable(self._context)
        self.input_actual = RootLuPid_controllerPid_wAttributeInput_actual(self._context)
        self.polarity = RootLuPid_controllerPid_wAttributePolarity(self._context)
        self.median_filter_enable = RootLuPid_controllerPid_wAttributeMedian_filter_enable(self._context)
        self.memory_signal_gen_drive_enable = RootLuPid_controllerPid_wAttributeMemory_signal_gen_drive_enable(self._context)
        self.select_output = RootLuPid_controllerPid_wAttributeSelect_output(self._context)
        self.compare_mode = RootLuPid_controllerPid_wAttributeCompare_mode(self._context)
        self.max_value = RootLuPid_controllerPid_wAttributeMax_value(self._context)
        self.input_set_point = RootLuPid_controllerPid_wAttributeInput_set_point(self._context)
        self.d_gain = RootLuPid_controllerPid_wAttributeD_gain(self._context)
        self.set_point_gain = RootLuPid_controllerPid_wAttributeSet_point_gain(self._context)
        self.slope = RootLuPid_controllerPid_wAttributeSlope(self._context)
        self.i_gain = RootLuPid_controllerPid_wAttributeI_gain(self._context)
        self.reached_min = RootLuPid_controllerPid_wAttributeReached_min(self._context)
        self.p_gain = RootLuPid_controllerPid_wAttributeP_gain(self._context)
        self.memory_signal_gen_position_enable = RootLuPid_controllerPid_wAttributeMemory_signal_gen_position_enable(self._context)


class RootLuPid_controllerPid_w(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_w'
        self.attribute = RootLuPid_controllerPid_wAttribute(self._context)
        self.trigger = RootLuPid_controllerPid_wTrigger(self._context)
        self.busy = RootLuPid_controllerPid_wBusy(self._context)


class RootLuPid_controllerPid_xBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.busy'


class RootLuPid_controllerPid_xTriggerDrive_to_zero_volt_position(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.trigger.drive_to_zero_volt_position'


class RootLuPid_controllerPid_xTriggerCalibrate_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.trigger.calibrate_offset'


class RootLuPid_controllerPid_xTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.trigger'
        self.calibrate_offset = RootLuPid_controllerPid_xTriggerCalibrate_offset(self._context)
        self.drive_to_zero_volt_position = RootLuPid_controllerPid_xTriggerDrive_to_zero_volt_position(self._context)

    def clear_pid_accu(self) -> None:
        return self._context.call('root.lu.pid_controller.pid_x.trigger.clear_pid_accu')


class RootLuPid_controllerPid_xAttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuPid_controllerPid_xAttributeP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.p_gain.value', float(new_val))


class RootLuPid_controllerPid_xAttributeReached_min(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.reached_min'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_min.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_min.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_min.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_min.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_min.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_min.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_min.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_min.value', float(new_val))


class RootLuPid_controllerPid_xAttributeI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.i_gain.value', float(new_val))


class RootLuPid_controllerPid_xAttributeSlope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.slope.value', float(new_val))


class RootLuPid_controllerPid_xAttributeSet_point_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.set_point_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_gain.value', float(new_val))


class RootLuPid_controllerPid_xAttributeD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.d_gain.value', float(new_val))


class RootLuPid_controllerPid_xAttributeInput_set_point(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.input_set_point'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeInput_set_point.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.input_set_point.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_set_point.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.input_set_point.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_set_point.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.input_set_point.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_set_point.enum', list(new_val))


class RootLuPid_controllerPid_xAttributeMax_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.max_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.max_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.max_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.max_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.max_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.max_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.max_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.max_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.max_value.value', float(new_val))


class RootLuPid_controllerPid_xAttributeCompare_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.compare_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.compare_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.compare_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.compare_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.compare_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.compare_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.compare_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.compare_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.compare_mode.value', float(new_val))


class RootLuPid_controllerPid_xAttributeSelect_output(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.select_output'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.select_output.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.select_output.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.select_output.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.select_output.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.select_output.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.select_output.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.select_output.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.select_output.value', float(new_val))


class RootLuPid_controllerPid_xAttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuPid_controllerPid_xAttributeMedian_filter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.median_filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeMedian_filter_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.median_filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.median_filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.median_filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.median_filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.median_filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.median_filter_enable.enum', list(new_val))


class RootLuPid_controllerPid_xAttributePolarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.polarity.value', float(new_val))


class RootLuPid_controllerPid_xAttributeInput_actual(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.input_actual'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeInput_actual.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.input_actual.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_actual.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.input_actual.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_actual.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.input_actual.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.input_actual.enum', list(new_val))


class RootLuPid_controllerPid_xAttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_xAttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_x.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuPid_controllerPid_xAttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.min_value.value', float(new_val))


class RootLuPid_controllerPid_xAttributeOffset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.offset.value', float(new_val))


class RootLuPid_controllerPid_xAttributeError_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.error_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.error_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.error_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.error_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.error_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.error_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.error_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.error_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.error_limit.value', float(new_val))


class RootLuPid_controllerPid_xAttributeFeedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.feedback_mode.value', float(new_val))


class RootLuPid_controllerPid_xAttributeReached_err_lim(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.reached_err_lim'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_err_lim.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_err_lim.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_err_lim.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_err_lim.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_err_lim.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_err_lim.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_err_lim.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_err_lim.value', float(new_val))


class RootLuPid_controllerPid_xAttributeReached_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute.reached_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_x.attribute.reached_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_x.attribute.reached_max.value', float(new_val))


class RootLuPid_controllerPid_xAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x.attribute'
        self.reached_max = RootLuPid_controllerPid_xAttributeReached_max(self._context)
        self.reached_err_lim = RootLuPid_controllerPid_xAttributeReached_err_lim(self._context)
        self.feedback_mode = RootLuPid_controllerPid_xAttributeFeedback_mode(self._context)
        self.error_limit = RootLuPid_controllerPid_xAttributeError_limit(self._context)
        self.offset = RootLuPid_controllerPid_xAttributeOffset(self._context)
        self.min_value = RootLuPid_controllerPid_xAttributeMin_value(self._context)
        self.set_point_modulation_enable = RootLuPid_controllerPid_xAttributeSet_point_modulation_enable(self._context)
        self.input_actual = RootLuPid_controllerPid_xAttributeInput_actual(self._context)
        self.polarity = RootLuPid_controllerPid_xAttributePolarity(self._context)
        self.median_filter_enable = RootLuPid_controllerPid_xAttributeMedian_filter_enable(self._context)
        self.memory_signal_gen_drive_enable = RootLuPid_controllerPid_xAttributeMemory_signal_gen_drive_enable(self._context)
        self.select_output = RootLuPid_controllerPid_xAttributeSelect_output(self._context)
        self.compare_mode = RootLuPid_controllerPid_xAttributeCompare_mode(self._context)
        self.max_value = RootLuPid_controllerPid_xAttributeMax_value(self._context)
        self.input_set_point = RootLuPid_controllerPid_xAttributeInput_set_point(self._context)
        self.d_gain = RootLuPid_controllerPid_xAttributeD_gain(self._context)
        self.set_point_gain = RootLuPid_controllerPid_xAttributeSet_point_gain(self._context)
        self.slope = RootLuPid_controllerPid_xAttributeSlope(self._context)
        self.i_gain = RootLuPid_controllerPid_xAttributeI_gain(self._context)
        self.reached_min = RootLuPid_controllerPid_xAttributeReached_min(self._context)
        self.p_gain = RootLuPid_controllerPid_xAttributeP_gain(self._context)
        self.memory_signal_gen_position_enable = RootLuPid_controllerPid_xAttributeMemory_signal_gen_position_enable(self._context)


class RootLuPid_controllerPid_x(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_x'
        self.attribute = RootLuPid_controllerPid_xAttribute(self._context)
        self.trigger = RootLuPid_controllerPid_xTrigger(self._context)
        self.busy = RootLuPid_controllerPid_xBusy(self._context)


class RootLuPid_controllerPid_user2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.busy'


class RootLuPid_controllerPid_user2TriggerDrive_to_zero_volt_position(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.trigger.drive_to_zero_volt_position'


class RootLuPid_controllerPid_user2TriggerCalibrate_offset(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.trigger.calibrate_offset'


class RootLuPid_controllerPid_user2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.trigger'
        self.calibrate_offset = RootLuPid_controllerPid_user2TriggerCalibrate_offset(self._context)
        self.drive_to_zero_volt_position = RootLuPid_controllerPid_user2TriggerDrive_to_zero_volt_position(self._context)

    def clear_pid_accu(self) -> None:
        return self._context.call('root.lu.pid_controller.pid_user2.trigger.clear_pid_accu')


class RootLuPid_controllerPid_user2AttributeMemory_signal_gen_position_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeMemory_signal_gen_position_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_position_enable.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributeP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.p_gain.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeReached_min(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.reached_min'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_min.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_min.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_min.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_min.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_min.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_min.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_min.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_min.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.i_gain.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeSlope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.slope.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.slope.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.slope.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.slope.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.slope.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.slope.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeSet_point_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.set_point_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_gain.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.d_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.d_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.d_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.d_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.d_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.d_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.d_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.d_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.d_gain.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeInput_set_point(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.input_set_point'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeInput_set_point.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_set_point.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_set_point.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_set_point.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_set_point.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_set_point.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_set_point.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributeMax_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.max_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.max_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.max_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.max_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.max_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.max_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.max_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.max_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.max_value.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeCompare_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.compare_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.compare_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.compare_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.compare_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.compare_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.compare_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.compare_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.compare_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.compare_mode.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeSelect_output(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.select_output'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.select_output.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.select_output.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.select_output.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.select_output.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.select_output.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.select_output.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.select_output.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.select_output.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeMemory_signal_gen_drive_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeMemory_signal_gen_drive_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.memory_signal_gen_drive_enable.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributeMedian_filter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.median_filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeMedian_filter_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.median_filter_enable.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributePolarity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.polarity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.polarity.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.polarity.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.polarity.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.polarity.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.polarity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.polarity.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.polarity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.polarity.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeInput_actual(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 50
        analyzer1_ctrl_delta_f = 11
        ort_baseline = 56
        analyzer1_y = 53
        analyzer2_phase = 13
        analyzer1_reference = 63
        ctrl_z_pid_command = 43
        analyzer2_ctrl_delta_f = 15
        analyzer2_x = 54
        analyzer1_phase = 9
        in_position_y = 21
        ctrl_user2_out = 51
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 19
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 20
        analyzer2_amplitude = 12
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        analyzer2_y = 55
        ctrl_y_out = 48
        static = 17
        analyzer1_ctrl_amplitude = 10
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 61
        in6 = 23
        analyzer2_ctrl_amplitude = 14
        in_user3 = 5
        ctrl_z_out = 46
        memory_gen_position_y = 26
        in_tip_current = 7
        ort_amplitude_reduction = 16
        analyzer1_x = 52
        in_user4 = 6
        ramp_gen_user4 = 37
        ort_adhesion_value = 58
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 28
        ort_baseline_corrected = 57
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 25
        in_user2 = 4
        in_user1 = 3
        in_position_z = 2
        analyzer2_reference = 64
        analyzer1_amplitude = 8
        ort_adhesion_position = 59
        gen_test_dynamic = 18
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 62
        ctrl_z_in = 41
        ctrl_x_out = 47
        ctrl_w_out = 49

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.input_actual'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeInput_actual.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_actual.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_actual.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_actual.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_actual.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.input_actual.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.input_actual.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributeSet_point_modulation_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPid_controllerPid_user2AttributeSet_point_modulation_enable.ValueEnum(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.set_point_modulation_enable.enum', list(new_val))


class RootLuPid_controllerPid_user2AttributeMin_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.min_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.min_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.min_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.min_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.min_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.min_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.min_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.min_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.min_value.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeOffset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.offset.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeError_limit(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.error_limit'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.error_limit.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.error_limit.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.error_limit.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.error_limit.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.error_limit.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.error_limit.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.error_limit.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.error_limit.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeFeedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.feedback_mode.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeReached_err_lim(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.reached_err_lim'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_err_lim.value', float(new_val))


class RootLuPid_controllerPid_user2AttributeReached_max(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute.reached_max'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_max.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_max.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_max.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_max.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_max.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_max.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.pid_controller.pid_user2.attribute.reached_max.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.pid_controller.pid_user2.attribute.reached_max.value', float(new_val))


class RootLuPid_controllerPid_user2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2.attribute'
        self.reached_max = RootLuPid_controllerPid_user2AttributeReached_max(self._context)
        self.reached_err_lim = RootLuPid_controllerPid_user2AttributeReached_err_lim(self._context)
        self.feedback_mode = RootLuPid_controllerPid_user2AttributeFeedback_mode(self._context)
        self.error_limit = RootLuPid_controllerPid_user2AttributeError_limit(self._context)
        self.offset = RootLuPid_controllerPid_user2AttributeOffset(self._context)
        self.min_value = RootLuPid_controllerPid_user2AttributeMin_value(self._context)
        self.set_point_modulation_enable = RootLuPid_controllerPid_user2AttributeSet_point_modulation_enable(self._context)
        self.input_actual = RootLuPid_controllerPid_user2AttributeInput_actual(self._context)
        self.polarity = RootLuPid_controllerPid_user2AttributePolarity(self._context)
        self.median_filter_enable = RootLuPid_controllerPid_user2AttributeMedian_filter_enable(self._context)
        self.memory_signal_gen_drive_enable = RootLuPid_controllerPid_user2AttributeMemory_signal_gen_drive_enable(self._context)
        self.select_output = RootLuPid_controllerPid_user2AttributeSelect_output(self._context)
        self.compare_mode = RootLuPid_controllerPid_user2AttributeCompare_mode(self._context)
        self.max_value = RootLuPid_controllerPid_user2AttributeMax_value(self._context)
        self.input_set_point = RootLuPid_controllerPid_user2AttributeInput_set_point(self._context)
        self.d_gain = RootLuPid_controllerPid_user2AttributeD_gain(self._context)
        self.set_point_gain = RootLuPid_controllerPid_user2AttributeSet_point_gain(self._context)
        self.slope = RootLuPid_controllerPid_user2AttributeSlope(self._context)
        self.i_gain = RootLuPid_controllerPid_user2AttributeI_gain(self._context)
        self.reached_min = RootLuPid_controllerPid_user2AttributeReached_min(self._context)
        self.p_gain = RootLuPid_controllerPid_user2AttributeP_gain(self._context)
        self.memory_signal_gen_position_enable = RootLuPid_controllerPid_user2AttributeMemory_signal_gen_position_enable(self._context)


class RootLuPid_controllerPid_user2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller.pid_user2'
        self.attribute = RootLuPid_controllerPid_user2Attribute(self._context)
        self.trigger = RootLuPid_controllerPid_user2Trigger(self._context)
        self.busy = RootLuPid_controllerPid_user2Busy(self._context)


class RootLuPid_controller(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.pid_controller'
        self.pid_user2 = RootLuPid_controllerPid_user2(self._context)
        self.pid_x = RootLuPid_controllerPid_x(self._context)
        self.pid_w = RootLuPid_controllerPid_w(self._context)
        self.pid_user1 = RootLuPid_controllerPid_user1(self._context)
        self.pid_y = RootLuPid_controllerPid_y(self._context)


class RootLuComp_dcInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.busy'


class RootLuComp_dcInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.trigger'

    def read_current_configuration(self) -> None:
        return self._context.call('root.lu.comp_dc.instance.trigger.read_current_configuration')

    def start_comp_dc_calibration(self) -> None:
        return self._context.call('root.lu.comp_dc.instance.trigger.start_comp_dc_calibration')

    def apply_new_configuration(self) -> None:
        return self._context.call('root.lu.comp_dc.instance.trigger.apply_new_configuration')

    def apply_new_nonlinear_configuration(self) -> None:
        return self._context.call('root.lu.comp_dc.instance.trigger.apply_new_nonlinear_configuration')

    def user_abort(self) -> None:
        return self._context.call('root.lu.comp_dc.instance.trigger.user_abort')


class RootLuComp_dcInstanceAttributeCoefficient_index(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.attribute.coefficient_index'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.coefficient_index.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.coefficient_index.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.coefficient_index.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.coefficient_index.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comp_dc.instance.attribute.coefficient_index.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comp_dc.instance.attribute.coefficient_index.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.coefficient_index.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.coefficient_index.value', float(new_val))


class RootLuComp_dcInstanceAttributeComp_dc_gain_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.attribute.comp_dc_gain_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_z.value', float(new_val))


class RootLuComp_dcInstanceAttributeComp_dc_gain_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.attribute.comp_dc_gain_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_x.value', float(new_val))


class RootLuComp_dcInstanceAttributeComp_dc_gain_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.attribute.comp_dc_gain_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comp_dc.instance.attribute.comp_dc_gain_y.value', float(new_val))


class RootLuComp_dcInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance.attribute'
        self.comp_dc_gain_y = RootLuComp_dcInstanceAttributeComp_dc_gain_y(self._context)
        self.comp_dc_gain_x = RootLuComp_dcInstanceAttributeComp_dc_gain_x(self._context)
        self.comp_dc_gain_z = RootLuComp_dcInstanceAttributeComp_dc_gain_z(self._context)
        self.coefficient_index = RootLuComp_dcInstanceAttributeCoefficient_index(self._context)


class RootLuComp_dcInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc.instance'
        self.attribute = RootLuComp_dcInstanceAttribute(self._context)
        self.trigger = RootLuComp_dcInstanceTrigger(self._context)
        self.busy = RootLuComp_dcInstanceBusy(self._context)


class RootLuComp_dc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comp_dc'
        self.instance = RootLuComp_dcInstance(self._context)


class RootLuMacro_cmdInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.busy'


class RootLuMacro_cmdInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.trigger'

    def move_to_abs_mo_pos(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.move_to_abs_mo_pos')

    def move_to_abs_xy_pos(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.move_to_abs_xy_pos')

    def activate_z_feedback(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.activate_z_feedback')

    def make_pause(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.make_pause')

    def auto_recalibrate_probe(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.auto_recalibrate_probe')

    def stop_z_feedback(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.stop_z_feedback')

    def user_abort(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.user_abort')

    def user_event(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.user_event')

    def move_to_stop_value_mo(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.move_to_stop_value_mo')

    def write_i2_c_data(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.write_i2_c_data')

    def move_to_rel_mo_pos(self) -> None:
        return self._context.call('root.lu.macro_cmd.instance.trigger.move_to_rel_mo_pos')


class RootLuMacro_cmdInstanceAttributeActive_sampler_set(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.active_sampler_set'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.active_sampler_set.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.active_sampler_set.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.active_sampler_set.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.active_sampler_set.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.active_sampler_set.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.active_sampler_set.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.active_sampler_set.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.active_sampler_set.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeAbsolute_y_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.absolute_y_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_y_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_y_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_y_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_y_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_y_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_y_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_y_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_y_pos.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeI2_c_data(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.i2_c_data'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_data.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_data.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_data.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_data.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_data.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_data.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_data.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_data.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeEnable_daq(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.enable_daq'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeMo_move_stop_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        is_greater_than = 1
        is_less_than = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.mo_move_stop_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMacro_cmdInstanceAttributeMo_move_stop_mode.ValueEnum(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_mode.enum', list(new_val))


class RootLuMacro_cmdInstanceAttributeModulation_output(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        tip_voltage = 2
        external_z = 3
        position_z = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.modulation_output'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMacro_cmdInstanceAttributeModulation_output.ValueEnum(self._context.get('root.lu.macro_cmd.instance.attribute.modulation_output.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.macro_cmd.instance.attribute.modulation_output.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.macro_cmd.instance.attribute.modulation_output.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.macro_cmd.instance.attribute.modulation_output.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.macro_cmd.instance.attribute.modulation_output.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.macro_cmd.instance.attribute.modulation_output.enum', list(new_val))


class RootLuMacro_cmdInstanceAttributeAbsolute_pos_mo(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.absolute_pos_mo'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_pos_mo.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeTarget_output_channel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.target_output_channel'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_output_channel.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_output_channel.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_output_channel.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_output_channel.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.target_output_channel.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_output_channel.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_output_channel.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_output_channel.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeTarget_z_ctrl_output_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.target_z_ctrl_output_mode.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeXy_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.xy_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.xy_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.xy_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.xy_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.xy_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.xy_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.xy_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.xy_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.xy_move_speed.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeMo_move_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.mo_move_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_speed.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeEnable_daq_sync_end(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.enable_daq_sync_end'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.enable_daq_sync_end.value', float(new_val))


class RootLuMacro_cmdInstanceAttributePause_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.pause_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.pause_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.pause_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.pause_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.pause_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.pause_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.pause_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.pause_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.pause_time.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeI2_c_bus(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        digital_io = 0
        aux = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.i2_c_bus'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMacro_cmdInstanceAttributeI2_c_bus.ValueEnum(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_bus.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_bus.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_bus.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_bus.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_bus.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_bus.enum', list(new_val))


class RootLuMacro_cmdInstanceAttributeMo_move_stop_feedback_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_feedback_mode.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeUser_event_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.user_event_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.user_event_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.user_event_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.user_event_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.user_event_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.user_event_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.user_event_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.user_event_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.user_event_id.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeSystem_abort_event_mask(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.system_abort_event_mask'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.system_abort_event_mask.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeMo_move_stop_value(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        z_off = 0
        z_on = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.mo_move_stop_value'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMacro_cmdInstanceAttributeMo_move_stop_value.ValueEnum(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.macro_cmd.instance.attribute.mo_move_stop_value.enum', list(new_val))


class RootLuMacro_cmdInstanceAttributeAbsolute_x_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.absolute_x_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_x_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_x_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_x_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_x_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_x_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_x_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.absolute_x_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.absolute_x_pos.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeRelative_pos_mo(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.relative_pos_mo'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.relative_pos_mo.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.relative_pos_mo.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.relative_pos_mo.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.relative_pos_mo.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.relative_pos_mo.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.relative_pos_mo.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.relative_pos_mo.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.relative_pos_mo.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeI2_c_register(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.i2_c_register'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_register.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_register.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_register.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_register.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_register.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_register.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_register.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_register.value', float(new_val))


class RootLuMacro_cmdInstanceAttributeI2_c_address(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute.i2_c_address'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_address.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_address.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_address.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_address.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_address.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_address.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.macro_cmd.instance.attribute.i2_c_address.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.macro_cmd.instance.attribute.i2_c_address.value', float(new_val))


class RootLuMacro_cmdInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance.attribute'
        self.i2_c_address = RootLuMacro_cmdInstanceAttributeI2_c_address(self._context)
        self.i2_c_register = RootLuMacro_cmdInstanceAttributeI2_c_register(self._context)
        self.relative_pos_mo = RootLuMacro_cmdInstanceAttributeRelative_pos_mo(self._context)
        self.absolute_x_pos = RootLuMacro_cmdInstanceAttributeAbsolute_x_pos(self._context)
        self.mo_move_stop_value = RootLuMacro_cmdInstanceAttributeMo_move_stop_value(self._context)
        self.system_abort_event_mask = RootLuMacro_cmdInstanceAttributeSystem_abort_event_mask(self._context)
        self.user_event_id = RootLuMacro_cmdInstanceAttributeUser_event_id(self._context)
        self.mo_move_stop_feedback_mode = RootLuMacro_cmdInstanceAttributeMo_move_stop_feedback_mode(self._context)
        self.i2_c_bus = RootLuMacro_cmdInstanceAttributeI2_c_bus(self._context)
        self.pause_time = RootLuMacro_cmdInstanceAttributePause_time(self._context)
        self.enable_daq_sync_end = RootLuMacro_cmdInstanceAttributeEnable_daq_sync_end(self._context)
        self.mo_move_speed = RootLuMacro_cmdInstanceAttributeMo_move_speed(self._context)
        self.xy_move_speed = RootLuMacro_cmdInstanceAttributeXy_move_speed(self._context)
        self.target_z_ctrl_output_mode = RootLuMacro_cmdInstanceAttributeTarget_z_ctrl_output_mode(self._context)
        self.target_output_channel = RootLuMacro_cmdInstanceAttributeTarget_output_channel(self._context)
        self.absolute_pos_mo = RootLuMacro_cmdInstanceAttributeAbsolute_pos_mo(self._context)
        self.modulation_output = RootLuMacro_cmdInstanceAttributeModulation_output(self._context)
        self.mo_move_stop_mode = RootLuMacro_cmdInstanceAttributeMo_move_stop_mode(self._context)
        self.enable_daq = RootLuMacro_cmdInstanceAttributeEnable_daq(self._context)
        self.i2_c_data = RootLuMacro_cmdInstanceAttributeI2_c_data(self._context)
        self.absolute_y_pos = RootLuMacro_cmdInstanceAttributeAbsolute_y_pos(self._context)
        self.active_sampler_set = RootLuMacro_cmdInstanceAttributeActive_sampler_set(self._context)


class RootLuMacro_cmdInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd.instance'
        self.attribute = RootLuMacro_cmdInstanceAttribute(self._context)
        self.trigger = RootLuMacro_cmdInstanceTrigger(self._context)
        self.busy = RootLuMacro_cmdInstanceBusy(self._context)


class RootLuMacro_cmd(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.macro_cmd'
        self.instance = RootLuMacro_cmdInstance(self._context)


class RootLuSignal_analyzerInst1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.busy'


class RootLuSignal_analyzerInst1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.trigger'

    def start_kpfm_phase_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.start_kpfm_phase_calibration')

    def start_phase_zero_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.start_phase_zero_calibration')

    def start_switch_to_target_amplitude_ctrl_mode(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.start_switch_to_target_amplitude_ctrl_mode')

    def kpfm_phase_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.kpfm_phase_calibration')

    def user_abort(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.user_abort')

    def start_update_current_free_amplitude(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.start_update_current_free_amplitude')

    def start_switch_to_target_amplitude_ctrl_set_point(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.start_switch_to_target_amplitude_ctrl_set_point')

    def switch_to_target_amplitude_ctrl_set_point(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.switch_to_target_amplitude_ctrl_set_point')

    def switch_to_target_amplitude_ctrl_mode(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst1.trigger.switch_to_target_amplitude_ctrl_mode')


class RootLuSignal_analyzerInst1AttributeOperating_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        lock_in = 0
        kpfm = 2
        pll = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.operating_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeOperating_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.operating_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.operating_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.operating_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.operating_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.operating_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.operating_mode.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_x_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_x_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x_binary.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_y_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_y_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y_binary.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeEnable_dc_block(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.enable_dc_block'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeEnable_dc_block.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.enable_dc_block.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeLock_in_calc_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_phase.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeReference_amplitude_factor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude_factor.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_i_gain.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeReset_flag_pll_unlocked(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reset_flag_pll_unlocked.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeTarget_amplitude_ctrl_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        const_amplitude = 1
        free_vibration = 2
        const_drive = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeTarget_amplitude_ctrl_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_mode.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributePhase_lock_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.phase_lock_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_lock_range.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeReference_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reference_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst1AttributePll_unlocked(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.pll_unlocked'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.pll_unlocked.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_amplitude_ctrl_set_point(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_set_point.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeHarmonic_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        analyzer1 = 0
        analyzer2 = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.harmonic_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeHarmonic_source.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.harmonic_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.harmonic_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.harmonic_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.harmonic_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.harmonic_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.harmonic_source.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_ctrl_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_x.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeDemodulator_bw(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        bw_500_k_hz = 15
        bw_750_hz = 6
        bw_3_k_hz = 8
        bw_23_k_hz = 11
        bw_6_k_hz = 9
        bw_180_hz = 4
        bw_1500_hz = 7
        bw_100_k_hz = 13
        bw_90_hz = 3
        bw_230_k_hz = 14
        bw_45_hz = 2
        bw_45_k_hz = 12
        bw_23_hz = 1
        bw_360_hz = 5
        bw_12_k_hz = 10

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.demodulator_bw'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeDemodulator_bw.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.demodulator_bw.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeReference_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reference_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_frequency.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeAmplitude_modulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.amplitude_modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeAmplitude_modulation.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_modulation.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributePhase_ctrl_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_i_gain.value', float(new_val))


class RootLuSignal_analyzerInst1AttributePhase_ctrl_p_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.phase_ctrl_p_gain.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_y.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeTarget_amplitude_ctrl_set_point(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.target_amplitude_ctrl_set_point.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeLock_in_calc_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.lock_in_calc_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_set_point_calib_result(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_error = 0
        amplitude_calibration_error = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_set_point_calib_result.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_set_point_calib_result.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 49
        analyzer1_ctrl_delta_f = 16
        ort_baseline = 61
        analyzer1_y = 54
        analyzer2_phase = 57
        test_ref = 10
        analyzer1_reference = 66
        ctrl_z_pid_command = 43
        test_tip_voltage = 11
        analyzer2_ctrl_delta_f = 55
        analyzer2_x = 59
        analyzer1_phase = 52
        in_position_y = 13
        ctrl_user2_out = 50
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 20
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 12
        analyzer2_amplitude = 58
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        test_ana_gnd = 9
        analyzer2_y = 60
        ctrl_y_out = 47
        static = 18
        analyzer1_ctrl_amplitude = 51
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 1
        in6 = 23
        analyzer2_ctrl_amplitude = 56
        in_user3 = 6
        ctrl_z_out = 17
        memory_gen_position_y = 26
        in_tip_current = 8
        ort_amplitude_reduction = 63
        analyzer1_x = 53
        in_user4 = 7
        ramp_gen_user4 = 37
        ort_adhesion_value = 64
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 21
        ort_free_wave = 69
        ort_excitation = 68
        memory_gen_position_z = 28
        ort_baseline_corrected = 62
        in_lateral = 3
        fast_in_deflection = 0
        memory_gen_drive_x = 25
        in_user2 = 5
        in_user1 = 4
        in_position_z = 14
        analyzer2_reference = 67
        analyzer1_amplitude = 15
        ort_adhesion_position = 65
        gen_test_dynamic = 19
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 2
        ctrl_z_in = 41
        ctrl_x_out = 46
        ctrl_w_out = 48

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeInput.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.input.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_amplitude_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_binary.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_ctrl_delta_f(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_ctrl_delta_f.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeDisplay_df_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.display_df_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.display_df_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.display_df_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.display_df_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.display_df_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.display_df_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.display_df_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.display_df_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.display_df_range.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeReference_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        own = 0
        harmonic3 = 3
        harmonic2 = 2
        harmonic1 = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reference_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeReference_source.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_source.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_amplitude_ctrl_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        const_amplitude = 1
        free_vibration = 2
        const_drive = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst1AttributeCurrent_amplitude_ctrl_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude_ctrl_mode.enum', list(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_p_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.amplitude_ctrl_p_gain.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_reference_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_reference_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeReference_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.reference_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.reference_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.reference_phase.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeDelay_comp(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.delay_comp'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.delay_comp.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.delay_comp.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.delay_comp.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.delay_comp.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.delay_comp.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.delay_comp.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.delay_comp.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.delay_comp.value', float(new_val))


class RootLuSignal_analyzerInst1AttributeCurrent_phase_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute.current_phase_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst1.attribute.current_phase_binary.value', float(new_val))


class RootLuSignal_analyzerInst1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1.attribute'
        self.current_phase_binary = RootLuSignal_analyzerInst1AttributeCurrent_phase_binary(self._context)
        self.delay_comp = RootLuSignal_analyzerInst1AttributeDelay_comp(self._context)
        self.reference_phase = RootLuSignal_analyzerInst1AttributeReference_phase(self._context)
        self.current_reference_amplitude = RootLuSignal_analyzerInst1AttributeCurrent_reference_amplitude(self._context)
        self.amplitude_ctrl_p_gain = RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_p_gain(self._context)
        self.current_amplitude = RootLuSignal_analyzerInst1AttributeCurrent_amplitude(self._context)
        self.current_amplitude_ctrl_mode = RootLuSignal_analyzerInst1AttributeCurrent_amplitude_ctrl_mode(self._context)
        self.current_phase = RootLuSignal_analyzerInst1AttributeCurrent_phase(self._context)
        self.reference_source = RootLuSignal_analyzerInst1AttributeReference_source(self._context)
        self.display_df_range = RootLuSignal_analyzerInst1AttributeDisplay_df_range(self._context)
        self.current_ctrl_delta_f = RootLuSignal_analyzerInst1AttributeCurrent_ctrl_delta_f(self._context)
        self.current_amplitude_binary = RootLuSignal_analyzerInst1AttributeCurrent_amplitude_binary(self._context)
        self.input = RootLuSignal_analyzerInst1AttributeInput(self._context)
        self.amplitude_ctrl_set_point_calib_result = RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_set_point_calib_result(self._context)
        self.lock_in_calc_amplitude = RootLuSignal_analyzerInst1AttributeLock_in_calc_amplitude(self._context)
        self.target_amplitude_ctrl_set_point = RootLuSignal_analyzerInst1AttributeTarget_amplitude_ctrl_set_point(self._context)
        self.current_y = RootLuSignal_analyzerInst1AttributeCurrent_y(self._context)
        self.phase_ctrl_p_gain = RootLuSignal_analyzerInst1AttributePhase_ctrl_p_gain(self._context)
        self.phase_ctrl_i_gain = RootLuSignal_analyzerInst1AttributePhase_ctrl_i_gain(self._context)
        self.amplitude_modulation = RootLuSignal_analyzerInst1AttributeAmplitude_modulation(self._context)
        self.reference_frequency = RootLuSignal_analyzerInst1AttributeReference_frequency(self._context)
        self.demodulator_bw = RootLuSignal_analyzerInst1AttributeDemodulator_bw(self._context)
        self.current_x = RootLuSignal_analyzerInst1AttributeCurrent_x(self._context)
        self.current_ctrl_amplitude = RootLuSignal_analyzerInst1AttributeCurrent_ctrl_amplitude(self._context)
        self.harmonic_source = RootLuSignal_analyzerInst1AttributeHarmonic_source(self._context)
        self.current_amplitude_ctrl_set_point = RootLuSignal_analyzerInst1AttributeCurrent_amplitude_ctrl_set_point(self._context)
        self.pll_unlocked = RootLuSignal_analyzerInst1AttributePll_unlocked(self._context)
        self.reference_amplitude = RootLuSignal_analyzerInst1AttributeReference_amplitude(self._context)
        self.phase_lock_range = RootLuSignal_analyzerInst1AttributePhase_lock_range(self._context)
        self.target_amplitude_ctrl_mode = RootLuSignal_analyzerInst1AttributeTarget_amplitude_ctrl_mode(self._context)
        self.reset_flag_pll_unlocked = RootLuSignal_analyzerInst1AttributeReset_flag_pll_unlocked(self._context)
        self.amplitude_ctrl_i_gain = RootLuSignal_analyzerInst1AttributeAmplitude_ctrl_i_gain(self._context)
        self.reference_amplitude_factor = RootLuSignal_analyzerInst1AttributeReference_amplitude_factor(self._context)
        self.lock_in_calc_phase = RootLuSignal_analyzerInst1AttributeLock_in_calc_phase(self._context)
        self.enable_dc_block = RootLuSignal_analyzerInst1AttributeEnable_dc_block(self._context)
        self.current_y_binary = RootLuSignal_analyzerInst1AttributeCurrent_y_binary(self._context)
        self.current_x_binary = RootLuSignal_analyzerInst1AttributeCurrent_x_binary(self._context)
        self.operating_mode = RootLuSignal_analyzerInst1AttributeOperating_mode(self._context)


class RootLuSignal_analyzerInst1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst1'
        self.attribute = RootLuSignal_analyzerInst1Attribute(self._context)
        self.trigger = RootLuSignal_analyzerInst1Trigger(self._context)
        self.busy = RootLuSignal_analyzerInst1Busy(self._context)


class RootLuSignal_analyzerInst2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.busy'


class RootLuSignal_analyzerInst2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.trigger'

    def start_kpfm_phase_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.start_kpfm_phase_calibration')

    def start_phase_zero_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.start_phase_zero_calibration')

    def start_switch_to_target_amplitude_ctrl_mode(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.start_switch_to_target_amplitude_ctrl_mode')

    def kpfm_phase_calibration(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.kpfm_phase_calibration')

    def user_abort(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.user_abort')

    def start_update_current_free_amplitude(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.start_update_current_free_amplitude')

    def start_switch_to_target_amplitude_ctrl_set_point(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.start_switch_to_target_amplitude_ctrl_set_point')

    def switch_to_target_amplitude_ctrl_set_point(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.switch_to_target_amplitude_ctrl_set_point')

    def switch_to_target_amplitude_ctrl_mode(self) -> None:
        return self._context.call('root.lu.signal_analyzer.inst2.trigger.switch_to_target_amplitude_ctrl_mode')


class RootLuSignal_analyzerInst2AttributeOperating_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        lock_in = 0
        kpfm = 2
        pll = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.operating_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeOperating_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.operating_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.operating_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.operating_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.operating_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.operating_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.operating_mode.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_x_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_x_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x_binary.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_y_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_y_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y_binary.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeEnable_dc_block(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.enable_dc_block'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeEnable_dc_block.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.enable_dc_block.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeLock_in_calc_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_phase.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeReference_amplitude_factor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude_factor.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_i_gain.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeReset_flag_pll_unlocked(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reset_flag_pll_unlocked.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeTarget_amplitude_ctrl_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        const_amplitude = 1
        free_vibration = 2
        const_drive = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeTarget_amplitude_ctrl_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_mode.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributePhase_lock_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.phase_lock_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_lock_range.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeReference_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reference_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst2AttributePll_unlocked(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.pll_unlocked'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.pll_unlocked.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_amplitude_ctrl_set_point(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_set_point.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeHarmonic_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        analyzer1 = 0
        analyzer2 = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.harmonic_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeHarmonic_source.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.harmonic_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.harmonic_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.harmonic_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.harmonic_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.harmonic_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.harmonic_source.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_ctrl_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_x.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeDemodulator_bw(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        bw_500_k_hz = 15
        bw_750_hz = 6
        bw_3_k_hz = 8
        bw_23_k_hz = 11
        bw_6_k_hz = 9
        bw_180_hz = 4
        bw_1500_hz = 7
        bw_100_k_hz = 13
        bw_90_hz = 3
        bw_230_k_hz = 14
        bw_45_hz = 2
        bw_45_k_hz = 12
        bw_23_hz = 1
        bw_360_hz = 5
        bw_12_k_hz = 10

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.demodulator_bw'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeDemodulator_bw.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.demodulator_bw.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeReference_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reference_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_frequency.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeAmplitude_modulation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.amplitude_modulation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeAmplitude_modulation.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_modulation.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributePhase_ctrl_i_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_i_gain.value', float(new_val))


class RootLuSignal_analyzerInst2AttributePhase_ctrl_p_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.phase_ctrl_p_gain.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_y.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeTarget_amplitude_ctrl_set_point(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.target_amplitude_ctrl_set_point.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeLock_in_calc_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.lock_in_calc_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_set_point_calib_result(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        no_error = 0
        amplitude_calibration_error = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_set_point_calib_result.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_set_point_calib_result.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeInput(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 29
        ramp_gen_ctrl_z = 39
        ctrl_z_sum = 44
        ctrl_user1_out = 49
        analyzer1_ctrl_delta_f = 16
        ort_baseline = 61
        analyzer1_y = 54
        analyzer2_phase = 57
        test_ref = 10
        analyzer1_reference = 66
        ctrl_z_pid_command = 43
        test_tip_voltage = 11
        analyzer2_ctrl_delta_f = 55
        analyzer2_x = 59
        analyzer1_phase = 52
        in_position_y = 13
        ctrl_user2_out = 50
        ramp_gen_alternate_z = 36
        in_detector_sum = 22
        ramp_gen_test = 20
        ramp_gen_approach = 32
        ctrl_z_nominal = 45
        in_position_x = 12
        analyzer2_amplitude = 58
        memory_gen_out7 = 30
        memory_gen_out8 = 31
        ramp_gen_position_y = 34
        test_ana_gnd = 9
        analyzer2_y = 60
        ctrl_y_out = 47
        static = 18
        analyzer1_ctrl_amplitude = 51
        ramp_gen_max_z = 40
        memory_gen_position_x = 24
        fast_in2 = 1
        in6 = 23
        analyzer2_ctrl_amplitude = 56
        in_user3 = 6
        ctrl_z_out = 17
        memory_gen_position_y = 26
        in_tip_current = 8
        ort_amplitude_reduction = 63
        analyzer1_x = 53
        in_user4 = 7
        ramp_gen_user4 = 37
        ort_adhesion_value = 64
        ramp_gen_tip_voltage = 35
        ramp_gen_position_x = 33
        ramp_gen_plane_z = 38
        in_deflection = 21
        ort_free_wave = 69
        ort_excitation = 68
        memory_gen_position_z = 28
        ort_baseline_corrected = 62
        in_lateral = 3
        fast_in_deflection = 0
        memory_gen_drive_x = 25
        in_user2 = 5
        in_user1 = 4
        in_position_z = 14
        analyzer2_reference = 67
        analyzer1_amplitude = 15
        ort_adhesion_position = 65
        gen_test_dynamic = 19
        ctrl_z_error = 42
        memory_gen_drive_y = 27
        fast_in_user = 2
        ctrl_z_in = 41
        ctrl_x_out = 46
        ctrl_w_out = 48

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.input'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeInput.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.input.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.input.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.input.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.input.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.input.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.input.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_amplitude_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_binary.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_ctrl_delta_f(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_ctrl_delta_f.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeDisplay_df_range(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.display_df_range'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.display_df_range.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.display_df_range.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.display_df_range.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.display_df_range.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.display_df_range.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.display_df_range.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.display_df_range.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.display_df_range.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeReference_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        own = 0
        harmonic3 = 3
        harmonic2 = 2
        harmonic1 = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reference_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeReference_source.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_source.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_amplitude_ctrl_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        const_amplitude = 1
        free_vibration = 2
        const_drive = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuSignal_analyzerInst2AttributeCurrent_amplitude_ctrl_mode.ValueEnum(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude_ctrl_mode.enum', list(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_p_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.amplitude_ctrl_p_gain.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_reference_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_reference_amplitude.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeReference_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.reference_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_phase.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_phase.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_phase.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_phase.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_phase.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.reference_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.reference_phase.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeDelay_comp(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.delay_comp'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.delay_comp.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.delay_comp.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.delay_comp.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.delay_comp.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.delay_comp.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.delay_comp.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.delay_comp.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.delay_comp.value', float(new_val))


class RootLuSignal_analyzerInst2AttributeCurrent_phase_binary(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute.current_phase_binary'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.signal_analyzer.inst2.attribute.current_phase_binary.value', float(new_val))


class RootLuSignal_analyzerInst2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2.attribute'
        self.current_phase_binary = RootLuSignal_analyzerInst2AttributeCurrent_phase_binary(self._context)
        self.delay_comp = RootLuSignal_analyzerInst2AttributeDelay_comp(self._context)
        self.reference_phase = RootLuSignal_analyzerInst2AttributeReference_phase(self._context)
        self.current_reference_amplitude = RootLuSignal_analyzerInst2AttributeCurrent_reference_amplitude(self._context)
        self.amplitude_ctrl_p_gain = RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_p_gain(self._context)
        self.current_amplitude = RootLuSignal_analyzerInst2AttributeCurrent_amplitude(self._context)
        self.current_amplitude_ctrl_mode = RootLuSignal_analyzerInst2AttributeCurrent_amplitude_ctrl_mode(self._context)
        self.current_phase = RootLuSignal_analyzerInst2AttributeCurrent_phase(self._context)
        self.reference_source = RootLuSignal_analyzerInst2AttributeReference_source(self._context)
        self.display_df_range = RootLuSignal_analyzerInst2AttributeDisplay_df_range(self._context)
        self.current_ctrl_delta_f = RootLuSignal_analyzerInst2AttributeCurrent_ctrl_delta_f(self._context)
        self.current_amplitude_binary = RootLuSignal_analyzerInst2AttributeCurrent_amplitude_binary(self._context)
        self.input = RootLuSignal_analyzerInst2AttributeInput(self._context)
        self.amplitude_ctrl_set_point_calib_result = RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_set_point_calib_result(self._context)
        self.lock_in_calc_amplitude = RootLuSignal_analyzerInst2AttributeLock_in_calc_amplitude(self._context)
        self.target_amplitude_ctrl_set_point = RootLuSignal_analyzerInst2AttributeTarget_amplitude_ctrl_set_point(self._context)
        self.current_y = RootLuSignal_analyzerInst2AttributeCurrent_y(self._context)
        self.phase_ctrl_p_gain = RootLuSignal_analyzerInst2AttributePhase_ctrl_p_gain(self._context)
        self.phase_ctrl_i_gain = RootLuSignal_analyzerInst2AttributePhase_ctrl_i_gain(self._context)
        self.amplitude_modulation = RootLuSignal_analyzerInst2AttributeAmplitude_modulation(self._context)
        self.reference_frequency = RootLuSignal_analyzerInst2AttributeReference_frequency(self._context)
        self.demodulator_bw = RootLuSignal_analyzerInst2AttributeDemodulator_bw(self._context)
        self.current_x = RootLuSignal_analyzerInst2AttributeCurrent_x(self._context)
        self.current_ctrl_amplitude = RootLuSignal_analyzerInst2AttributeCurrent_ctrl_amplitude(self._context)
        self.harmonic_source = RootLuSignal_analyzerInst2AttributeHarmonic_source(self._context)
        self.current_amplitude_ctrl_set_point = RootLuSignal_analyzerInst2AttributeCurrent_amplitude_ctrl_set_point(self._context)
        self.pll_unlocked = RootLuSignal_analyzerInst2AttributePll_unlocked(self._context)
        self.reference_amplitude = RootLuSignal_analyzerInst2AttributeReference_amplitude(self._context)
        self.phase_lock_range = RootLuSignal_analyzerInst2AttributePhase_lock_range(self._context)
        self.target_amplitude_ctrl_mode = RootLuSignal_analyzerInst2AttributeTarget_amplitude_ctrl_mode(self._context)
        self.reset_flag_pll_unlocked = RootLuSignal_analyzerInst2AttributeReset_flag_pll_unlocked(self._context)
        self.amplitude_ctrl_i_gain = RootLuSignal_analyzerInst2AttributeAmplitude_ctrl_i_gain(self._context)
        self.reference_amplitude_factor = RootLuSignal_analyzerInst2AttributeReference_amplitude_factor(self._context)
        self.lock_in_calc_phase = RootLuSignal_analyzerInst2AttributeLock_in_calc_phase(self._context)
        self.enable_dc_block = RootLuSignal_analyzerInst2AttributeEnable_dc_block(self._context)
        self.current_y_binary = RootLuSignal_analyzerInst2AttributeCurrent_y_binary(self._context)
        self.current_x_binary = RootLuSignal_analyzerInst2AttributeCurrent_x_binary(self._context)
        self.operating_mode = RootLuSignal_analyzerInst2AttributeOperating_mode(self._context)


class RootLuSignal_analyzerInst2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer.inst2'
        self.attribute = RootLuSignal_analyzerInst2Attribute(self._context)
        self.trigger = RootLuSignal_analyzerInst2Trigger(self._context)
        self.busy = RootLuSignal_analyzerInst2Busy(self._context)


class RootLuSignal_analyzer(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.signal_analyzer'
        self.inst2 = RootLuSignal_analyzerInst2(self._context)
        self.inst1 = RootLuSignal_analyzerInst1(self._context)


class RootLuAnalog_fast_inCh2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.busy'


class RootLuAnalog_fast_inCh2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.trigger'


class RootLuAnalog_fast_inCh2AttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_fast_inCh2AttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_fast_inCh2AttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inCh2AttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_fast_inCh2AttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inCh2AttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_inCh2AttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_inCh2AttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_inCh2AttributeInput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.input_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_gain.value', float(new_val))


class RootLuAnalog_fast_inCh2AttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.ch2.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.ch2.attribute.input_offset.value', float(new_val))


class RootLuAnalog_fast_inCh2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2.attribute'
        self.input_offset = RootLuAnalog_fast_inCh2AttributeInput_offset(self._context)
        self.input_gain = RootLuAnalog_fast_inCh2AttributeInput_gain(self._context)
        self.calib_offset = RootLuAnalog_fast_inCh2AttributeCalib_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_inCh2AttributeCalib_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_inCh2AttributeCalib_polarity(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_fast_inCh2AttributeCross_coupling_axis_id(self._context)
        self.current_input_value = RootLuAnalog_fast_inCh2AttributeCurrent_input_value(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_fast_inCh2AttributeCross_coupling_axis_coefficient_vec(self._context)


class RootLuAnalog_fast_inCh2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.ch2'
        self.attribute = RootLuAnalog_fast_inCh2Attribute(self._context)
        self.trigger = RootLuAnalog_fast_inCh2Trigger(self._context)
        self.busy = RootLuAnalog_fast_inCh2Busy(self._context)


class RootLuAnalog_fast_inUserBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.busy'


class RootLuAnalog_fast_inUserTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.trigger'


class RootLuAnalog_fast_inUserAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_fast_inUserAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_fast_inUserAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inUserAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.user.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_fast_inUserAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inUserAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_in.user.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.user.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.user.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_inUserAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_inUserAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_inUserAttributeInput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.input_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.input_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_gain.value', float(new_val))


class RootLuAnalog_fast_inUserAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.user.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.user.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.user.attribute.input_offset.value', float(new_val))


class RootLuAnalog_fast_inUserAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user.attribute'
        self.input_offset = RootLuAnalog_fast_inUserAttributeInput_offset(self._context)
        self.input_gain = RootLuAnalog_fast_inUserAttributeInput_gain(self._context)
        self.calib_offset = RootLuAnalog_fast_inUserAttributeCalib_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_inUserAttributeCalib_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_inUserAttributeCalib_polarity(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_fast_inUserAttributeCross_coupling_axis_id(self._context)
        self.current_input_value = RootLuAnalog_fast_inUserAttributeCurrent_input_value(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_fast_inUserAttributeCross_coupling_axis_coefficient_vec(self._context)


class RootLuAnalog_fast_inUser(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.user'
        self.attribute = RootLuAnalog_fast_inUserAttribute(self._context)
        self.trigger = RootLuAnalog_fast_inUserTrigger(self._context)
        self.busy = RootLuAnalog_fast_inUserBusy(self._context)


class RootLuAnalog_fast_inDeflectionBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.busy'


class RootLuAnalog_fast_inDeflectionTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.trigger'


class RootLuAnalog_fast_inDeflectionAttributeCross_coupling_axis_coefficient_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_coefficient_vec.vector', list(new_val))


class RootLuAnalog_fast_inDeflectionAttributeCurrent_input_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.current_input_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.current_input_value.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.current_input_value.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.current_input_value.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.current_input_value.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.current_input_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.current_input_value.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.current_input_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.current_input_value.value', float(new_val))


class RootLuAnalog_fast_inDeflectionAttributeCross_coupling_axis_id(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        self = 3
        position_z = 2
        position_x = 0
        position_y = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inDeflectionAttributeCross_coupling_axis_id.ValueEnum(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.cross_coupling_axis_id.enum', list(new_val))


class RootLuAnalog_fast_inDeflectionAttributeCalib_polarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        positive = 0
        negative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.calib_polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuAnalog_fast_inDeflectionAttributeCalib_polarity.ValueEnum(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_polarity.enum', list(new_val))


class RootLuAnalog_fast_inDeflectionAttributeCalib_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.calib_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_gain.value', float(new_val))


class RootLuAnalog_fast_inDeflectionAttributeCalib_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.calib_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.calib_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.calib_offset.value', float(new_val))


class RootLuAnalog_fast_inDeflectionAttributeInput_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.input_gain'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_gain.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_gain.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_gain.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_gain.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_gain.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_gain.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_gain.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_gain.value', float(new_val))


class RootLuAnalog_fast_inDeflectionAttributeInput_offset(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute.input_offset'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_offset.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_offset.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_offset.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_offset.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_offset.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_offset.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.analog_fast_in.deflection.attribute.input_offset.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.analog_fast_in.deflection.attribute.input_offset.value', float(new_val))


class RootLuAnalog_fast_inDeflectionAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection.attribute'
        self.input_offset = RootLuAnalog_fast_inDeflectionAttributeInput_offset(self._context)
        self.input_gain = RootLuAnalog_fast_inDeflectionAttributeInput_gain(self._context)
        self.calib_offset = RootLuAnalog_fast_inDeflectionAttributeCalib_offset(self._context)
        self.calib_gain = RootLuAnalog_fast_inDeflectionAttributeCalib_gain(self._context)
        self.calib_polarity = RootLuAnalog_fast_inDeflectionAttributeCalib_polarity(self._context)
        self.cross_coupling_axis_id = RootLuAnalog_fast_inDeflectionAttributeCross_coupling_axis_id(self._context)
        self.current_input_value = RootLuAnalog_fast_inDeflectionAttributeCurrent_input_value(self._context)
        self.cross_coupling_axis_coefficient_vec = RootLuAnalog_fast_inDeflectionAttributeCross_coupling_axis_coefficient_vec(self._context)


class RootLuAnalog_fast_inDeflection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in.deflection'
        self.attribute = RootLuAnalog_fast_inDeflectionAttribute(self._context)
        self.trigger = RootLuAnalog_fast_inDeflectionTrigger(self._context)
        self.busy = RootLuAnalog_fast_inDeflectionBusy(self._context)


class RootLuAnalog_fast_in(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.analog_fast_in'
        self.deflection = RootLuAnalog_fast_inDeflection(self._context)
        self.user = RootLuAnalog_fast_inUser(self._context)
        self.ch2 = RootLuAnalog_fast_inCh2(self._context)


class RootLuThermal_tuningInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning.instance.busy'


class RootLuThermal_tuningInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning.instance.trigger'

    def start_block(self) -> None:
        return self._context.call('root.lu.thermal_tuning.instance.trigger.start_block')

    def user_abort(self) -> None:
        return self._context.call('root.lu.thermal_tuning.instance.trigger.user_abort')


class RootLuThermal_tuningInstanceAttributeBuffer_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning.instance.attribute.buffer_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.thermal_tuning.instance.attribute.buffer_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.thermal_tuning.instance.attribute.buffer_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.thermal_tuning.instance.attribute.buffer_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.thermal_tuning.instance.attribute.buffer_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.thermal_tuning.instance.attribute.buffer_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.thermal_tuning.instance.attribute.buffer_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.thermal_tuning.instance.attribute.buffer_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.thermal_tuning.instance.attribute.buffer_group_id.value', float(new_val))


class RootLuThermal_tuningInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning.instance.attribute'
        self.buffer_group_id = RootLuThermal_tuningInstanceAttributeBuffer_group_id(self._context)


class RootLuThermal_tuningInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning.instance'
        self.attribute = RootLuThermal_tuningInstanceAttribute(self._context)
        self.trigger = RootLuThermal_tuningInstanceTrigger(self._context)
        self.busy = RootLuThermal_tuningInstanceBusy(self._context)


class RootLuThermal_tuning(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.thermal_tuning'
        self.instance = RootLuThermal_tuningInstance(self._context)


class RootLuDirect_motor_controlInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.busy'


class RootLuDirect_motor_controlInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.trigger'

    def search_reference(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.search_reference')

    def position_zero_axis(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.position_zero_axis')

    def reset_transaction(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.reset_transaction')

    def add_transaction_move(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.add_transaction_move')

    def commit_transaction(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.commit_transaction')

    def user_abort(self) -> None:
        return self._context.call('root.lu.direct_motor_control.instance.trigger.user_abort')


class RootLuDirect_motor_controlInstanceAttributeAxis_speed_factor(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_speed_factor'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_speed_factor.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttributeCurrent_axis(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        approach_2 = 1003
        lens_gimbal = 1013
        y_axis = 1012
        x_axis = 1011
        photothermal_excitation_spot_vert = 1006
        approach = 1000
        approach_0 = 1001
        photothermal_excitation_spot_horz = 1005
        photodiode_detector_vert = 1010
        all = 0
        focus_cantilever_light_source = 1004
        beam_deflection_spot_horz = 1007
        photodiode_detector_horz = 1009
        beam_deflection_spot_vert = 1008
        approach_1 = 1002

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.current_axis'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeCurrent_axis.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.current_axis.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_axis.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.current_axis.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_axis.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.current_axis.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_axis.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeTransaction_move_relative(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        absolute = 0
        relative = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.transaction_move_relative'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeTransaction_move_relative.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_relative.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeAxis_max_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_max_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_max_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_max_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_max_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_max_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_max_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_max_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_max_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_max_speed.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttributeAxis_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        moving = 3
        idle_referenced = 1
        idle_unreferenced = 0
        not_mapped = 4
        referencing = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeAxis_status.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_status.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeTransaction_move_destination(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.transaction_move_destination'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.transaction_move_destination.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttributeMove_adjust(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.move_adjust'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.move_adjust.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.move_adjust.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.move_adjust.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.move_adjust.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.move_adjust.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.move_adjust.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.move_adjust.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.move_adjust.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttributeLayout_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        not_loaded = 2
        uninitialized = 0
        initialized = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.layout_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeLayout_status.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.layout_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.layout_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.layout_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.layout_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.layout_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.layout_status.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeAxis_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_position.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_position.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_position.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_position.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_position.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_position.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttributeCurrent_layout(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        arac = 7
        core = 6
        dummy4 = 4
        all = 0
        p6_mount = 8
        dummy2 = 2
        sim = 5
        dummy3 = 3
        p6 = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.current_layout'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeCurrent_layout.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.current_layout.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_layout.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.current_layout.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_layout.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.current_layout.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.current_layout.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeAxis_limit_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        in_lower_limit = 2
        in_both_limits = 3
        in_no_limit = 0
        in_upper_limit = 1
        in_limit = 4

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_limit_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuDirect_motor_controlInstanceAttributeAxis_limit_status.ValueEnum(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_limit_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_limit_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_limit_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_limit_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_limit_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_limit_status.enum', list(new_val))


class RootLuDirect_motor_controlInstanceAttributeAxis_last_reference_move_distance(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.direct_motor_control.instance.attribute.axis_last_reference_move_distance.value', float(new_val))


class RootLuDirect_motor_controlInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance.attribute'
        self.axis_last_reference_move_distance = RootLuDirect_motor_controlInstanceAttributeAxis_last_reference_move_distance(self._context)
        self.axis_limit_status = RootLuDirect_motor_controlInstanceAttributeAxis_limit_status(self._context)
        self.current_layout = RootLuDirect_motor_controlInstanceAttributeCurrent_layout(self._context)
        self.axis_position = RootLuDirect_motor_controlInstanceAttributeAxis_position(self._context)
        self.layout_status = RootLuDirect_motor_controlInstanceAttributeLayout_status(self._context)
        self.move_adjust = RootLuDirect_motor_controlInstanceAttributeMove_adjust(self._context)
        self.transaction_move_destination = RootLuDirect_motor_controlInstanceAttributeTransaction_move_destination(self._context)
        self.axis_status = RootLuDirect_motor_controlInstanceAttributeAxis_status(self._context)
        self.axis_max_speed = RootLuDirect_motor_controlInstanceAttributeAxis_max_speed(self._context)
        self.transaction_move_relative = RootLuDirect_motor_controlInstanceAttributeTransaction_move_relative(self._context)
        self.current_axis = RootLuDirect_motor_controlInstanceAttributeCurrent_axis(self._context)
        self.axis_speed_factor = RootLuDirect_motor_controlInstanceAttributeAxis_speed_factor(self._context)


class RootLuDirect_motor_controlInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control.instance'
        self.attribute = RootLuDirect_motor_controlInstanceAttribute(self._context)
        self.trigger = RootLuDirect_motor_controlInstanceTrigger(self._context)
        self.busy = RootLuDirect_motor_controlInstanceBusy(self._context)


class RootLuDirect_motor_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.direct_motor_control'
        self.instance = RootLuDirect_motor_controlInstance(self._context)


class RootLuComparatorComparator2Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.busy'


class RootLuComparatorComparator2Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.trigger'


class RootLuComparatorComparator2AttributeFilter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute.filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator2AttributeFilter_enable.ValueEnum(self._context.get('root.lu.comparator.comparator2.attribute.filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator2.attribute.filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator2.attribute.filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_enable.enum', list(new_val))


class RootLuComparatorComparator2AttributeLevel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute.level'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator2.attribute.level.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator2.attribute.level.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator2.attribute.level.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator2.attribute.level.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator2.attribute.level.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator2.attribute.level.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator2.attribute.level.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comparator.comparator2.attribute.level.value', float(new_val))


class RootLuComparatorComparator2AttributeSource(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute.source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator2AttributeSource.ValueEnum(self._context.get('root.lu.comparator.comparator2.attribute.source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator2.attribute.source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator2.attribute.source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator2.attribute.source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator2.attribute.source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator2.attribute.source.enum', list(new_val))


class RootLuComparatorComparator2AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator2.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator2.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator2.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator2.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.comparator.comparator2.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuComparatorComparator2AttributePolarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        equal_or_lower_than = 0
        equal_or_higher_than = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute.polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator2AttributePolarity.ValueEnum(self._context.get('root.lu.comparator.comparator2.attribute.polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator2.attribute.polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator2.attribute.polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator2.attribute.polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator2.attribute.polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator2.attribute.polarity.enum', list(new_val))


class RootLuComparatorComparator2Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2.attribute'
        self.polarity = RootLuComparatorComparator2AttributePolarity(self._context)
        self.filter_coeff_vec = RootLuComparatorComparator2AttributeFilter_coeff_vec(self._context)
        self.source = RootLuComparatorComparator2AttributeSource(self._context)
        self.level = RootLuComparatorComparator2AttributeLevel(self._context)
        self.filter_enable = RootLuComparatorComparator2AttributeFilter_enable(self._context)


class RootLuComparatorComparator2(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator2'
        self.attribute = RootLuComparatorComparator2Attribute(self._context)
        self.trigger = RootLuComparatorComparator2Trigger(self._context)
        self.busy = RootLuComparatorComparator2Busy(self._context)


class RootLuComparatorComparator1Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.busy'


class RootLuComparatorComparator1Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.trigger'


class RootLuComparatorComparator1AttributeFilter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute.filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator1AttributeFilter_enable.ValueEnum(self._context.get('root.lu.comparator.comparator1.attribute.filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator1.attribute.filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator1.attribute.filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_enable.enum', list(new_val))


class RootLuComparatorComparator1AttributeLevel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute.level'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator1.attribute.level.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator1.attribute.level.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator1.attribute.level.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator1.attribute.level.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator1.attribute.level.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator1.attribute.level.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator1.attribute.level.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comparator.comparator1.attribute.level.value', float(new_val))


class RootLuComparatorComparator1AttributeSource(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute.source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator1AttributeSource.ValueEnum(self._context.get('root.lu.comparator.comparator1.attribute.source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator1.attribute.source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator1.attribute.source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator1.attribute.source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator1.attribute.source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator1.attribute.source.enum', list(new_val))


class RootLuComparatorComparator1AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator1.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator1.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator1.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator1.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.comparator.comparator1.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuComparatorComparator1AttributePolarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        equal_or_lower_than = 0
        equal_or_higher_than = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute.polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator1AttributePolarity.ValueEnum(self._context.get('root.lu.comparator.comparator1.attribute.polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator1.attribute.polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator1.attribute.polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator1.attribute.polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator1.attribute.polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator1.attribute.polarity.enum', list(new_val))


class RootLuComparatorComparator1Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1.attribute'
        self.polarity = RootLuComparatorComparator1AttributePolarity(self._context)
        self.filter_coeff_vec = RootLuComparatorComparator1AttributeFilter_coeff_vec(self._context)
        self.source = RootLuComparatorComparator1AttributeSource(self._context)
        self.level = RootLuComparatorComparator1AttributeLevel(self._context)
        self.filter_enable = RootLuComparatorComparator1AttributeFilter_enable(self._context)


class RootLuComparatorComparator1(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator1'
        self.attribute = RootLuComparatorComparator1Attribute(self._context)
        self.trigger = RootLuComparatorComparator1Trigger(self._context)
        self.busy = RootLuComparatorComparator1Busy(self._context)


class RootLuComparatorComparator3Busy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.busy'


class RootLuComparatorComparator3Trigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.trigger'


class RootLuComparatorComparator3AttributeFilter_enable(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute.filter_enable'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator3AttributeFilter_enable.ValueEnum(self._context.get('root.lu.comparator.comparator3.attribute.filter_enable.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_enable.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator3.attribute.filter_enable.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_enable.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator3.attribute.filter_enable.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_enable.enum', list(new_val))


class RootLuComparatorComparator3AttributeLevel(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute.level'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator3.attribute.level.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator3.attribute.level.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator3.attribute.level.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator3.attribute.level.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator3.attribute.level.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator3.attribute.level.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator3.attribute.level.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.comparator.comparator3.attribute.level.value', float(new_val))


class RootLuComparatorComparator3AttributeSource(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        memory_gen_drive_z = 56
        ramp_gen_ctrl_z = 37
        ctrl_z_sum = 40
        ctrl_user1_out = 44
        analyzer1_ctrl_delta_f = 21
        ort_baseline = 46
        analyzer1_y = 19
        analyzer2_phase = 23
        analyzer1_reference = 63
        ctrl_z_pid_command = 39
        analyzer2_ctrl_delta_f = 27
        analyzer2_x = 24
        analyzer1_phase = 17
        in_position_y = 3
        ctrl_user2_out = 45
        ramp_gen_alternate_z = 29
        in_detector_sum = 10
        ramp_gen_test = 32
        ramp_gen_approach = 33
        ctrl_z_nominal = 15
        in_position_x = 2
        analyzer2_amplitude = 22
        memory_gen_out7 = 57
        memory_gen_out8 = 58
        ramp_gen_position_y = 35
        analyzer2_y = 25
        ctrl_y_out = 42
        static = 30
        analyzer1_ctrl_amplitude = 20
        ramp_gen_max_z = 38
        memory_gen_position_x = 51
        fast_in2 = 61
        in6 = 11
        analyzer2_ctrl_amplitude = 26
        in_user3 = 7
        ctrl_z_out = 14
        memory_gen_position_y = 53
        in_tip_current = 9
        ort_amplitude_reduction = 48
        analyzer1_x = 18
        in_user4 = 8
        ramp_gen_user4 = 59
        ort_adhesion_value = 49
        ramp_gen_tip_voltage = 28
        ramp_gen_position_x = 34
        ramp_gen_plane_z = 36
        in_deflection = 0
        ort_free_wave = 66
        ort_excitation = 65
        memory_gen_position_z = 55
        ort_baseline_corrected = 47
        in_lateral = 1
        fast_in_deflection = 60
        memory_gen_drive_x = 52
        in_user2 = 6
        in_user1 = 5
        in_position_z = 4
        analyzer2_reference = 64
        analyzer1_amplitude = 16
        ort_adhesion_position = 50
        gen_test_dynamic = 31
        ctrl_z_error = 13
        memory_gen_drive_y = 54
        fast_in_user = 62
        ctrl_z_in = 12
        ctrl_x_out = 41
        ctrl_w_out = 43

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute.source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator3AttributeSource.ValueEnum(self._context.get('root.lu.comparator.comparator3.attribute.source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator3.attribute.source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator3.attribute.source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator3.attribute.source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator3.attribute.source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator3.attribute.source.enum', list(new_val))


class RootLuComparatorComparator3AttributeFilter_coeff_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute.filter_coeff_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator3.attribute.filter_coeff_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_coeff_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.comparator.comparator3.attribute.filter_coeff_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_coeff_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.comparator.comparator3.attribute.filter_coeff_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_coeff_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator3.attribute.filter_coeff_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.comparator.comparator3.attribute.filter_coeff_vec.vector', list(new_val))


class RootLuComparatorComparator3AttributePolarity(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        equal_or_lower_than = 0
        equal_or_higher_than = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute.polarity'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuComparatorComparator3AttributePolarity.ValueEnum(self._context.get('root.lu.comparator.comparator3.attribute.polarity.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.comparator.comparator3.attribute.polarity.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.comparator.comparator3.attribute.polarity.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.comparator.comparator3.attribute.polarity.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.comparator.comparator3.attribute.polarity.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.comparator.comparator3.attribute.polarity.enum', list(new_val))


class RootLuComparatorComparator3Attribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3.attribute'
        self.polarity = RootLuComparatorComparator3AttributePolarity(self._context)
        self.filter_coeff_vec = RootLuComparatorComparator3AttributeFilter_coeff_vec(self._context)
        self.source = RootLuComparatorComparator3AttributeSource(self._context)
        self.level = RootLuComparatorComparator3AttributeLevel(self._context)
        self.filter_enable = RootLuComparatorComparator3AttributeFilter_enable(self._context)


class RootLuComparatorComparator3(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator.comparator3'
        self.attribute = RootLuComparatorComparator3Attribute(self._context)
        self.trigger = RootLuComparatorComparator3Trigger(self._context)
        self.busy = RootLuComparatorComparator3Busy(self._context)


class RootLuComparator(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.comparator'
        self.comparator3 = RootLuComparatorComparator3(self._context)
        self.comparator1 = RootLuComparatorComparator1(self._context)
        self.comparator2 = RootLuComparatorComparator2(self._context)


class RootLuHv_amplifierInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.busy'


class RootLuHv_amplifierInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.trigger'

    def enable_module(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.enable_module')

    def enable_power(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.enable_power')

    def disable_z_modulation(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.disable_z_modulation')

    def switch_to_target_mode(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.switch_to_target_mode')

    def disable_module(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.disable_module')

    def disable_power(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.disable_power')

    def depreciated_6(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.depreciated_6')

    def start_switch_to_target_mode(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.start_switch_to_target_mode')

    def enable_z_modulation(self) -> None:
        return self._context.call('root.lu.hv_amplifier.instance.trigger.enable_z_modulation')


class RootLuHv_amplifierInstanceAttributeInterlock_open_cx_cable(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_cx_cable.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeMode_current(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        off = 0
        lv = 2
        hv = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.mode_current'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuHv_amplifierInstanceAttributeMode_current.ValueEnum(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_current.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_current.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_current.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_current.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_current.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_current.enum', list(new_val))


class RootLuHv_amplifierInstanceAttributeTemperature(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.temperature'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.temperature.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.temperature.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.temperature.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.temperature.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.temperature.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.temperature.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.temperature.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.temperature.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeOutput_discharge_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.output_discharge_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.output_discharge_delay.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeInterlock_open_hv_cable(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_hv_cable.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeMode_target(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        off = 0
        lv = 2
        hv = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.mode_target'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuHv_amplifierInstanceAttributeMode_target.ValueEnum(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_target.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_target.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_target.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_target.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.hv_amplifier.instance.attribute.mode_target.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.hv_amplifier.instance.attribute.mode_target.enum', list(new_val))


class RootLuHv_amplifierInstanceAttributeInterlock_open_user(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.interlock_open_user'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_user.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_user.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_user.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_user.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_user.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_user.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.interlock_open_user.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.interlock_open_user.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeLast_mode_switch_retval(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        mode_not_supported = 1
        interlock_open = 2
        ok = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuHv_amplifierInstanceAttributeLast_mode_switch_retval.ValueEnum(self._context.get('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.hv_amplifier.instance.attribute.last_mode_switch_retval.enum', list(new_val))


class RootLuHv_amplifierInstanceAttributePower_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.power_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.power_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.power_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.power_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.power_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.power_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.power_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.power_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.power_enabled.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeType(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        unknown = 1
        hv500 = 4
        not_connected = 0
        hv180 = 3
        a201 = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.type'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuHv_amplifierInstanceAttributeType.ValueEnum(self._context.get('root.lu.hv_amplifier.instance.attribute.type.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.hv_amplifier.instance.attribute.type.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.hv_amplifier.instance.attribute.type.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.hv_amplifier.instance.attribute.type.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.hv_amplifier.instance.attribute.type.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.hv_amplifier.instance.attribute.type.enum', list(new_val))


class RootLuHv_amplifierInstanceAttributeHv_module_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.hv_module_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.hv_module_enabled.value', float(new_val))


class RootLuHv_amplifierInstanceAttributeZ_modulation_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute.z_modulation_enabled'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.hv_amplifier.instance.attribute.z_modulation_enabled.value', float(new_val))


class RootLuHv_amplifierInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance.attribute'
        self.z_modulation_enabled = RootLuHv_amplifierInstanceAttributeZ_modulation_enabled(self._context)
        self.hv_module_enabled = RootLuHv_amplifierInstanceAttributeHv_module_enabled(self._context)
        self.type = RootLuHv_amplifierInstanceAttributeType(self._context)
        self.power_enabled = RootLuHv_amplifierInstanceAttributePower_enabled(self._context)
        self.last_mode_switch_retval = RootLuHv_amplifierInstanceAttributeLast_mode_switch_retval(self._context)
        self.interlock_open_user = RootLuHv_amplifierInstanceAttributeInterlock_open_user(self._context)
        self.mode_target = RootLuHv_amplifierInstanceAttributeMode_target(self._context)
        self.interlock_open_hv_cable = RootLuHv_amplifierInstanceAttributeInterlock_open_hv_cable(self._context)
        self.output_discharge_delay = RootLuHv_amplifierInstanceAttributeOutput_discharge_delay(self._context)
        self.temperature = RootLuHv_amplifierInstanceAttributeTemperature(self._context)
        self.mode_current = RootLuHv_amplifierInstanceAttributeMode_current(self._context)
        self.interlock_open_cx_cable = RootLuHv_amplifierInstanceAttributeInterlock_open_cx_cable(self._context)


class RootLuHv_amplifierInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier.instance'
        self.attribute = RootLuHv_amplifierInstanceAttribute(self._context)
        self.trigger = RootLuHv_amplifierInstanceTrigger(self._context)
        self.busy = RootLuHv_amplifierInstanceBusy(self._context)


class RootLuHv_amplifier(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.hv_amplifier'
        self.instance = RootLuHv_amplifierInstance(self._context)


class RootLuFrequency_sweep_genInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.busy'


class RootLuFrequency_sweep_genInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.trigger'

    def start_set_sensor_amplitude(self) -> None:
        return self._context.call('root.lu.frequency_sweep_gen.instance.trigger.start_set_sensor_amplitude')

    def start_frequency_sweep(self) -> None:
        return self._context.call('root.lu.frequency_sweep_gen.instance.trigger.start_frequency_sweep')

    def start_set_reference_amplitude(self) -> None:
        return self._context.call('root.lu.frequency_sweep_gen.instance.trigger.start_set_reference_amplitude')

    def user_abort(self) -> None:
        return self._context.call('root.lu.frequency_sweep_gen.instance.trigger.user_abort')


class RootLuFrequency_sweep_genInstanceAttributeEnd_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.end_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.end_frequency.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeSweep_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sweep_amplitude.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeSensor_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.sensor_amplitude.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeLu_sig_analyzer_inst_no(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        inst2 = 1
        inst1 = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuFrequency_sweep_genInstanceAttributeLu_sig_analyzer_inst_no.ValueEnum(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.lu_sig_analyzer_inst_no.enum', list(new_val))


class RootLuFrequency_sweep_genInstanceAttributeData_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.data_points'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_points.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_points.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_points.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_points.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_points.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_points.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_points.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_points.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeData_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.data_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.data_group_id.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeSettle_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.settle_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.settle_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.settle_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.settle_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.settle_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.settle_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.settle_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.settle_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.settle_time.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeReference_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.reference_amplitude.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeStart_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.start_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.start_frequency.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttributeStep_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute.step_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.step_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.step_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.step_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.step_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.step_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.step_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.frequency_sweep_gen.instance.attribute.step_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.frequency_sweep_gen.instance.attribute.step_time.value', float(new_val))


class RootLuFrequency_sweep_genInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance.attribute'
        self.step_time = RootLuFrequency_sweep_genInstanceAttributeStep_time(self._context)
        self.start_frequency = RootLuFrequency_sweep_genInstanceAttributeStart_frequency(self._context)
        self.reference_amplitude = RootLuFrequency_sweep_genInstanceAttributeReference_amplitude(self._context)
        self.settle_time = RootLuFrequency_sweep_genInstanceAttributeSettle_time(self._context)
        self.data_group_id = RootLuFrequency_sweep_genInstanceAttributeData_group_id(self._context)
        self.data_points = RootLuFrequency_sweep_genInstanceAttributeData_points(self._context)
        self.lu_sig_analyzer_inst_no = RootLuFrequency_sweep_genInstanceAttributeLu_sig_analyzer_inst_no(self._context)
        self.sensor_amplitude = RootLuFrequency_sweep_genInstanceAttributeSensor_amplitude(self._context)
        self.sweep_amplitude = RootLuFrequency_sweep_genInstanceAttributeSweep_amplitude(self._context)
        self.end_frequency = RootLuFrequency_sweep_genInstanceAttributeEnd_frequency(self._context)


class RootLuFrequency_sweep_genInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen.instance'
        self.attribute = RootLuFrequency_sweep_genInstanceAttribute(self._context)
        self.trigger = RootLuFrequency_sweep_genInstanceTrigger(self._context)
        self.busy = RootLuFrequency_sweep_genInstanceBusy(self._context)


class RootLuFrequency_sweep_gen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.frequency_sweep_gen'
        self.instance = RootLuFrequency_sweep_genInstance(self._context)


class RootLuPosition_controlInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.busy'

    @property
    def is_tip_moving(self) -> bool:
        return bool(self._context.call('root.lu.position_control.instance.busy.is_tip_moving'))

    @property
    def is_range_switching(self) -> bool:
        return bool(self._context.call('root.lu.position_control.instance.busy.is_range_switching'))

    @property
    def is_calibrating(self) -> bool:
        return bool(self._context.call('root.lu.position_control.instance.busy.is_calibrating'))

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.position_control.instance.busy.is_busy'))


class RootLuPosition_controlInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.trigger'

    def start_move_to_target_fix_speed_xy(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_move_to_target_fix_speed_xy')

    def start_move_to_target_fix_time_xyz(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_move_to_target_fix_time_xyz')

    def move_to_target_fix_time_xyz(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.move_to_target_fix_time_xyz')

    def start_move_to_target_fix_speed_xyz(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_move_to_target_fix_speed_xyz')

    def move_to_target_fix_time_xy(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.move_to_target_fix_time_xy')

    def move_to_target_fix_speed_xy(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.move_to_target_fix_speed_xy')

    def start_calib_xy_sensor_zero_to_center_of_ramp(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_calib_xy_sensor_zero_to_center_of_ramp')

    def move_to_target_fix_speed_xyz(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.move_to_target_fix_speed_xyz')

    def start_switch_to_target_scan_axis_range_select(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_switch_to_target_scan_axis_range_select')

    def calib_xy_sensor_zero_to_center_of_ramp(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.calib_xy_sensor_zero_to_center_of_ramp')

    def start_move_to_target_fix_time_xy(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.start_move_to_target_fix_time_xy')

    def switch_to_target_scan_axis_range_select(self) -> None:
        return self._context.call('root.lu.position_control.instance.trigger.switch_to_target_scan_axis_range_select')


class RootLuPosition_controlInstanceAttributeScan_correction_y_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.scan_correction_y_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_y_rotation.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_y_rotation.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_y_rotation.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_y_rotation.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.scan_correction_y_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_y_rotation.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_y_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_y_rotation.value', float(new_val))


class RootLuPosition_controlInstanceAttributePid_controller_settings_x(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        i_gain = 1
        d_gain = 2
        p_gain = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.pid_controller_settings_x'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributePid_controller_settings_x.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_x.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_x.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_x.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_x.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_x.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_x.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeEnable_xy_closed_loop(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.enable_xy_closed_loop'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.enable_xy_closed_loop.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.enable_xy_closed_loop.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.enable_xy_closed_loop.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.enable_xy_closed_loop.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.enable_xy_closed_loop.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.enable_xy_closed_loop.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.enable_xy_closed_loop.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.enable_xy_closed_loop.value', float(new_val))


class RootLuPosition_controlInstanceAttributeRamp_count(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.ramp_count'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_count.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_count.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_count.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_count.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.ramp_count.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.ramp_count.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_count.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_count.value', float(new_val))


class RootLuPosition_controlInstanceAttributeScan_correction_x_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.scan_correction_x_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_x_rotation.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_x_rotation.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_x_rotation.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_x_rotation.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.scan_correction_x_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_x_rotation.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.scan_correction_x_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.scan_correction_x_rotation.value', float(new_val))


class RootLuPosition_controlInstanceAttributeTarget_moving_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_moving_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_speed.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_speed.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_speed.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_speed.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.target_moving_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_speed.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_speed.value', float(new_val))


class RootLuPosition_controlInstanceAttributeAxis_scale_xylv(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.axis_scale_xylv'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xylv.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xylv.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xylv.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xylv.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xylv.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xylv.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xylv.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xylv.value', float(new_val))


class RootLuPosition_controlInstanceAttributeTarget_move_pos_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_move_pos_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_x.value', float(new_val))


class RootLuPosition_controlInstanceAttributeLast_scan_axis_range_select_switch_result(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        full_range = 1
        reduced_range = 2
        off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeLast_scan_axis_range_select_switch_result.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.last_scan_axis_range_select_switch_result.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeAxis_scale_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.axis_scale_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.axis_scale_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_z.value', float(new_val))


class RootLuPosition_controlInstanceAttributeIs_xy_closed_loop_possible(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        not_possible = 0
        possible = 1
        not_possible_wrong_scan_axis_range = -2
        not_possible_no_sensor = -1
        not_possible_no_scan_head = -3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.is_xy_closed_loop_possible'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeIs_xy_closed_loop_possible.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.is_xy_closed_loop_possible.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeTarget_move_pos_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_move_pos_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_z.value', float(new_val))


class RootLuPosition_controlInstanceAttributeRamp_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.ramp_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.ramp_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.ramp_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.ramp_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.ramp_time.value', float(new_val))


class RootLuPosition_controlInstanceAttributeAxis_scale_xy(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.axis_scale_xy'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xy.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xy.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xy.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xy.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xy.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xy.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_xy.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_xy.value', float(new_val))


class RootLuPosition_controlInstanceAttributeTarget_move_pos_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_move_pos_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_move_pos_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_move_pos_y.value', float(new_val))


class RootLuPosition_controlInstanceAttributeCurrent_pos_z(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.current_pos_z'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_z.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_z.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_z.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_z.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.current_pos_z.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_z.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_z.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_z.value', float(new_val))


class RootLuPosition_controlInstanceAttributeTarget_moving_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_moving_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.target_moving_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.target_moving_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.target_moving_time.value', float(new_val))


class RootLuPosition_controlInstanceAttributeCurrent_pos_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.current_pos_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_y.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_y.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_y.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_y.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.current_pos_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_y.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_y.value', float(new_val))


class RootLuPosition_controlInstanceAttributeTarget_scan_axis_range_select(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        full_range = 1
        reduced_range = 2
        off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.target_scan_axis_range_select'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeTarget_scan_axis_range_select.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.target_scan_axis_range_select.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.target_scan_axis_range_select.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.target_scan_axis_range_select.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.target_scan_axis_range_select.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.target_scan_axis_range_select.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.target_scan_axis_range_select.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeCurrent_scan_axis_range_select(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        full_range = 1
        reduced_range = 2
        off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.current_scan_axis_range_select'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeCurrent_scan_axis_range_select.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.current_scan_axis_range_select.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.current_scan_axis_range_select.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.current_scan_axis_range_select.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.current_scan_axis_range_select.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.current_scan_axis_range_select.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.current_scan_axis_range_select.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeCurrent_pos_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.current_pos_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_x.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_x.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_x.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_x.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.current_pos_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_x.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.current_pos_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.current_pos_x.value', float(new_val))


class RootLuPosition_controlInstanceAttributePid_controller_settings_y(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        i_gain = 1
        d_gain = 2
        p_gain = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.pid_controller_settings_y'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributePid_controller_settings_y.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_y.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_y.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_y.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_y.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.pid_controller_settings_y.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.pid_controller_settings_y.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeAxis_scale_zlv(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.axis_scale_zlv'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_zlv.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_zlv.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_zlv.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_zlv.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.axis_scale_zlv.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_zlv.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.axis_scale_zlv.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.axis_scale_zlv.value', float(new_val))


class RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_keep_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_keep_pos.value', float(new_val))


class RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_moving(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_moving.value', float(new_val))


class RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        moving = 0
        keep_position = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_mode.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.xy_closed_loop_speed_mode.enum', list(new_val))


class RootLuPosition_controlInstanceAttributeLast_move_stop_event(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        out_of_data = 7
        setpoint_reached = 2
        out_of_bound_min = 9
        out_of_bound_max = 8
        finish = 0
        user_abort = 4
        out_of_bound_upper_limit = 6
        out_of_bound_lower_limit = 5
        timer_expired = 3
        position_reached = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute.last_move_stop_event'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuPosition_controlInstanceAttributeLast_move_stop_event.ValueEnum(self._context.get('root.lu.position_control.instance.attribute.last_move_stop_event.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.position_control.instance.attribute.last_move_stop_event.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.position_control.instance.attribute.last_move_stop_event.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.position_control.instance.attribute.last_move_stop_event.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.position_control.instance.attribute.last_move_stop_event.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.position_control.instance.attribute.last_move_stop_event.enum', list(new_val))


class RootLuPosition_controlInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance.attribute'
        self.last_move_stop_event = RootLuPosition_controlInstanceAttributeLast_move_stop_event(self._context)
        self.xy_closed_loop_speed_mode = RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_mode(self._context)
        self.xy_closed_loop_speed_moving = RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_moving(self._context)
        self.xy_closed_loop_speed_keep_pos = RootLuPosition_controlInstanceAttributeXy_closed_loop_speed_keep_pos(self._context)
        self.axis_scale_zlv = RootLuPosition_controlInstanceAttributeAxis_scale_zlv(self._context)
        self.pid_controller_settings_y = RootLuPosition_controlInstanceAttributePid_controller_settings_y(self._context)
        self.current_pos_x = RootLuPosition_controlInstanceAttributeCurrent_pos_x(self._context)
        self.current_scan_axis_range_select = RootLuPosition_controlInstanceAttributeCurrent_scan_axis_range_select(self._context)
        self.target_scan_axis_range_select = RootLuPosition_controlInstanceAttributeTarget_scan_axis_range_select(self._context)
        self.current_pos_y = RootLuPosition_controlInstanceAttributeCurrent_pos_y(self._context)
        self.target_moving_time = RootLuPosition_controlInstanceAttributeTarget_moving_time(self._context)
        self.current_pos_z = RootLuPosition_controlInstanceAttributeCurrent_pos_z(self._context)
        self.target_move_pos_y = RootLuPosition_controlInstanceAttributeTarget_move_pos_y(self._context)
        self.axis_scale_xy = RootLuPosition_controlInstanceAttributeAxis_scale_xy(self._context)
        self.ramp_time = RootLuPosition_controlInstanceAttributeRamp_time(self._context)
        self.target_move_pos_z = RootLuPosition_controlInstanceAttributeTarget_move_pos_z(self._context)
        self.is_xy_closed_loop_possible = RootLuPosition_controlInstanceAttributeIs_xy_closed_loop_possible(self._context)
        self.axis_scale_z = RootLuPosition_controlInstanceAttributeAxis_scale_z(self._context)
        self.last_scan_axis_range_select_switch_result = RootLuPosition_controlInstanceAttributeLast_scan_axis_range_select_switch_result(self._context)
        self.target_move_pos_x = RootLuPosition_controlInstanceAttributeTarget_move_pos_x(self._context)
        self.axis_scale_xylv = RootLuPosition_controlInstanceAttributeAxis_scale_xylv(self._context)
        self.target_moving_speed = RootLuPosition_controlInstanceAttributeTarget_moving_speed(self._context)
        self.scan_correction_x_rotation = RootLuPosition_controlInstanceAttributeScan_correction_x_rotation(self._context)
        self.ramp_count = RootLuPosition_controlInstanceAttributeRamp_count(self._context)
        self.enable_xy_closed_loop = RootLuPosition_controlInstanceAttributeEnable_xy_closed_loop(self._context)
        self.pid_controller_settings_x = RootLuPosition_controlInstanceAttributePid_controller_settings_x(self._context)
        self.scan_correction_y_rotation = RootLuPosition_controlInstanceAttributeScan_correction_y_rotation(self._context)


class RootLuPosition_controlInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control.instance'
        self.attribute = RootLuPosition_controlInstanceAttribute(self._context)
        self.trigger = RootLuPosition_controlInstanceTrigger(self._context)
        self.busy = RootLuPosition_controlInstanceBusy(self._context)


class RootLuPosition_control(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.position_control'
        self.instance = RootLuPosition_controlInstance(self._context)


class RootLuMemory_signal_genInstanceBusy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.busy'

    @property
    def is_busy(self) -> bool:
        return bool(self._context.call('root.lu.memory_signal_gen.instance.busy.is_busy'))


class RootLuMemory_signal_genInstanceTrigger(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.trigger'

    def start(self) -> None:
        return self._context.call('root.lu.memory_signal_gen.instance.trigger.start')

    def prepare(self) -> None:
        return self._context.call('root.lu.memory_signal_gen.instance.trigger.prepare')

    def enable_preset_value(self) -> None:
        return self._context.call('root.lu.memory_signal_gen.instance.trigger.enable_preset_value')

    def stop(self) -> None:
        return self._context.call('root.lu.memory_signal_gen.instance.trigger.stop')

    def abort(self) -> None:
        return self._context.call('root.lu.memory_signal_gen.instance.trigger.abort')


class RootLuMemory_signal_genInstanceAttributeEnd_reached(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.end_reached'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.end_reached.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.end_reached.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.end_reached.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.end_reached.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.end_reached.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.end_reached.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.end_reached.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.end_reached.value', float(new_val))


class RootLuMemory_signal_genInstanceAttributeLinear_interpolation(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.linear_interpolation'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMemory_signal_genInstanceAttributeLinear_interpolation.ValueEnum(self._context.get('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.linear_interpolation.enum', list(new_val))


class RootLuMemory_signal_genInstanceAttributeCurrent_datapoint(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.current_datapoint'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.current_datapoint.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.current_datapoint.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.current_datapoint.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.current_datapoint.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.current_datapoint.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.current_datapoint.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.current_datapoint.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.current_datapoint.value', float(new_val))


class RootLuMemory_signal_genInstanceAttributeOffset_value_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_binary_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeLast_datapoint_value_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_binary_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeLast_datapoint_value_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.last_datapoint_value_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeOffset_value_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.offset_value_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.offset_value_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeData_group_id(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.data_group_id'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.data_group_id.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.data_group_id.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.data_group_id.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.data_group_id.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.data_group_id.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.data_group_id.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.data_group_id.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.data_group_id.value', float(new_val))


class RootLuMemory_signal_genInstanceAttributeJoin(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        disabled = 0
        enabled = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.join'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootLuMemory_signal_genInstanceAttributeJoin.ValueEnum(self._context.get('root.lu.memory_signal_gen.instance.attribute.join.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.join.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.lu.memory_signal_gen.instance.attribute.join.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.join.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.join.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.join.enum', list(new_val))


class RootLuMemory_signal_genInstanceAttributeFirst_datapoint_value_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeOutput_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.output_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_binary_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeFirst_datapoint_value_binary_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.first_datapoint_value_binary_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeOutput_vec(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.output_vec'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_vec.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_vec.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_vec.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_vec.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_vec.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_vec.unit', str(new_val))

    @property
    def value(self) -> list:
        return list(self._context.get('root.lu.memory_signal_gen.instance.attribute.output_vec.vector'))

    @value.setter
    def value(self, new_val:list):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.output_vec.vector', list(new_val))


class RootLuMemory_signal_genInstanceAttributeUnder_run(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.under_run'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.under_run.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.under_run.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.under_run.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.under_run.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.under_run.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.under_run.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.under_run.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.under_run.value', float(new_val))


class RootLuMemory_signal_genInstanceAttributeSweep_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute.sweep_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def min(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.sweep_time.min'))

    @min.setter
    def min(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.sweep_time.min', float(new_val))

    @property
    def max(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.sweep_time.max'))

    @max.setter
    def max(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.sweep_time.max', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.lu.memory_signal_gen.instance.attribute.sweep_time.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.sweep_time.unit', str(new_val))

    @property
    def value(self) -> float:
        return float(self._context.get('root.lu.memory_signal_gen.instance.attribute.sweep_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.lu.memory_signal_gen.instance.attribute.sweep_time.value', float(new_val))


class RootLuMemory_signal_genInstanceAttribute(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance.attribute'
        self.sweep_time = RootLuMemory_signal_genInstanceAttributeSweep_time(self._context)
        self.under_run = RootLuMemory_signal_genInstanceAttributeUnder_run(self._context)
        self.output_vec = RootLuMemory_signal_genInstanceAttributeOutput_vec(self._context)
        self.first_datapoint_value_binary_vec = RootLuMemory_signal_genInstanceAttributeFirst_datapoint_value_binary_vec(self._context)
        self.output_binary_vec = RootLuMemory_signal_genInstanceAttributeOutput_binary_vec(self._context)
        self.first_datapoint_value_vec = RootLuMemory_signal_genInstanceAttributeFirst_datapoint_value_vec(self._context)
        self.join = RootLuMemory_signal_genInstanceAttributeJoin(self._context)
        self.data_group_id = RootLuMemory_signal_genInstanceAttributeData_group_id(self._context)
        self.offset_value_vec = RootLuMemory_signal_genInstanceAttributeOffset_value_vec(self._context)
        self.last_datapoint_value_vec = RootLuMemory_signal_genInstanceAttributeLast_datapoint_value_vec(self._context)
        self.last_datapoint_value_binary_vec = RootLuMemory_signal_genInstanceAttributeLast_datapoint_value_binary_vec(self._context)
        self.offset_value_binary_vec = RootLuMemory_signal_genInstanceAttributeOffset_value_binary_vec(self._context)
        self.current_datapoint = RootLuMemory_signal_genInstanceAttributeCurrent_datapoint(self._context)
        self.linear_interpolation = RootLuMemory_signal_genInstanceAttributeLinear_interpolation(self._context)
        self.end_reached = RootLuMemory_signal_genInstanceAttributeEnd_reached(self._context)


class RootLuMemory_signal_genInstance(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen.instance'
        self.attribute = RootLuMemory_signal_genInstanceAttribute(self._context)
        self.trigger = RootLuMemory_signal_genInstanceTrigger(self._context)
        self.busy = RootLuMemory_signal_genInstanceBusy(self._context)


class RootLuMemory_signal_gen(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu.memory_signal_gen'
        self.instance = RootLuMemory_signal_genInstance(self._context)


class RootLu(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.lu'
        self.memory_signal_gen = RootLuMemory_signal_gen(self._context)
        self.position_control = RootLuPosition_control(self._context)
        self.frequency_sweep_gen = RootLuFrequency_sweep_gen(self._context)
        self.hv_amplifier = RootLuHv_amplifier(self._context)
        self.comparator = RootLuComparator(self._context)
        self.direct_motor_control = RootLuDirect_motor_control(self._context)
        self.thermal_tuning = RootLuThermal_tuning(self._context)
        self.analog_fast_in = RootLuAnalog_fast_in(self._context)
        self.signal_analyzer = RootLuSignal_analyzer(self._context)
        self.macro_cmd = RootLuMacro_cmd(self._context)
        self.comp_dc = RootLuComp_dc(self._context)
        self.pid_controller = RootLuPid_controller(self._context)
        self.sensor_control = RootLuSensor_control(self._context)
        self.cantilever_properties = RootLuCantilever_properties(self._context)
        self.analog_hi_res_out = RootLuAnalog_hi_res_out(self._context)
        self.mainboard_relays = RootLuMainboard_relays(self._context)
        self.analog_fast_out = RootLuAnalog_fast_out(self._context)
        self.z_controller_ex = RootLuZ_controller_ex(self._context)
        self.timer = RootLuTimer(self._context)
        self.test = RootLuTest(self._context)
        self.system_infra = RootLuSystem_infra(self._context)
        self.digi_user_io = RootLuDigi_user_io(self._context)
        self.ramp_generator = RootLuRamp_generator(self._context)
        self.sequencer = RootLuSequencer(self._context)
        self.scanhead = RootLuScanhead(self._context)
        self.scan = RootLuScan(self._context)
        self.rescan = RootLuRescan(self._context)
        self.ort = RootLuOrt(self._context)
        self.analog_hi_res_in = RootLuAnalog_hi_res_in(self._context)
        self.spec = RootLuSpec(self._context)
        self.isostage = RootLuIsostage(self._context)
        self.data_acquisition = RootLuData_acquisition(self._context)
        self.oscilloscope = RootLuOscilloscope(self._context)
        self.litho = RootLuLitho(self._context)
        self.event_manager = RootLuEvent_manager(self._context)
        self.auto_alignment = RootLuAuto_alignment(self._context)
        self.system = RootLuSystem(self._context)
        self.approach = RootLuApproach(self._context)

    def load_lu_interface_shared(self, *args) -> Any:
        return self._context.call('root.lu.load_lu_interface_shared', *args)


class RootWorkflowCantileverPropertySelected_cantilever_index(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.cantilever.property.selected_cantilever_index'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.cantilever.property.selected_cantilever_index.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.cantilever.property.selected_cantilever_index.value', int(new_val))


class RootWorkflowCantileverPropertySelected_cantilever_spring_constant(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.cantilever.property.selected_cantilever_spring_constant'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.cantilever.property.selected_cantilever_spring_constant.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.cantilever.property.selected_cantilever_spring_constant.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.cantilever.property.selected_cantilever_spring_constant.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.cantilever.property.selected_cantilever_spring_constant.unit', str(new_val))


class RootWorkflowCantileverPropertySelected_cantilever_deflection_sensitivity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.cantilever.property.selected_cantilever_deflection_sensitivity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.cantilever.property.selected_cantilever_deflection_sensitivity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.cantilever.property.selected_cantilever_deflection_sensitivity.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.cantilever.property.selected_cantilever_deflection_sensitivity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.cantilever.property.selected_cantilever_deflection_sensitivity.unit', str(new_val))


class RootWorkflowCantileverProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.cantilever.property'
        self.selected_cantilever_deflection_sensitivity = RootWorkflowCantileverPropertySelected_cantilever_deflection_sensitivity(self._context)
        self.selected_cantilever_spring_constant = RootWorkflowCantileverPropertySelected_cantilever_spring_constant(self._context)
        self.selected_cantilever_index = RootWorkflowCantileverPropertySelected_cantilever_index(self._context)


class RootWorkflowCantilever(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.cantilever'
        self.property = RootWorkflowCantileverProperty(self._context)

    def selected_cantilever(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.selected_cantilever', *args)

    def spring_constant(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.spring_constant', *args)

    def resonance_frequency(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.resonance_frequency', *args)

    def deflection_sensitivity(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.deflection_sensitivity', *args)

    def apply(self, *args) -> Any:
        return self._context.call('root.workflow.cantilever.apply', *args)


class RootWorkflowAutomationPropertyQueue_size(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.automation.property.queue_size'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.automation.property.queue_size.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.automation.property.queue_size.value', int(new_val))


class RootWorkflowAutomationPropertyQueue_index(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.automation.property.queue_index'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.automation.property.queue_index.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.automation.property.queue_index.value', int(new_val))


class RootWorkflowAutomationProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.automation.property'
        self.queue_index = RootWorkflowAutomationPropertyQueue_index(self._context)
        self.queue_size = RootWorkflowAutomationPropertyQueue_size(self._context)


class RootWorkflowAutomation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.automation'
        self.property = RootWorkflowAutomationProperty(self._context)

    def is_running(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_running', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.workflow.automation.abort', *args)

    def remove_from_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.remove_from_queue', *args)

    def pause(self, *args) -> Any:
        return self._context.call('root.workflow.automation.pause', *args)

    def add_all_accessible_items_to_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.add_all_accessible_items_to_queue', *args)

    def is_item_queued(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_item_queued', *args)

    def clear_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.clear_queue', *args)

    def add_to_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.add_to_queue', *args)

    def update_queue_entry(self, *args) -> Any:
        return self._context.call('root.workflow.automation.update_queue_entry', *args)

    def is_idle(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_idle', *args)

    def start(self, *args) -> Any:
        return self._context.call('root.workflow.automation.start', *args)

    def reset_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.reset_queue', *args)

    def resume(self, *args) -> Any:
        return self._context.call('root.workflow.automation.resume', *args)

    def queue_index_by_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_index_by_item_id', *args)

    def queue_size(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_size', *args)

    def queue_index_by_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_index_by_item_name', *args)

    def queue_info(self, *args) -> Any:
        return self._context.call('root.workflow.automation.queue_info', *args)

    def process(self, *args) -> Any:
        return self._context.call('root.workflow.automation.process', *args)

    def is_paused(self, *args) -> Any:
        return self._context.call('root.workflow.automation.is_paused', *args)

    def insert_in_queue(self, *args) -> Any:
        return self._context.call('root.workflow.automation.insert_in_queue', *args)

    def move_queue_entry(self, *args) -> Any:
        return self._context.call('root.workflow.automation.move_queue_entry', *args)


class RootWorkflowCamera_properties(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.camera_properties'


class RootWorkflowOscilloscope(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.oscilloscope'


class RootWorkflowLaser_alignSignalMotor_move_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.signal.motor_move_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_finished.connect_extended', *args)


class RootWorkflowLaser_alignSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.procedure_info.connect_extended', *args)


class RootWorkflowLaser_alignSignalMotor_move_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.signal.motor_move_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.signal.motor_move_started.connect_extended', *args)


class RootWorkflowLaser_alignSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.signal'
        self.motor_move_started = RootWorkflowLaser_alignSignalMotor_move_started(self._context)
        self.procedure_info = RootWorkflowLaser_alignSignalProcedure_info(self._context)
        self.motor_move_finished = RootWorkflowLaser_alignSignalMotor_move_finished(self._context)


class RootWorkflowLaser_alignPropertyLaser_clean_drive_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_clean_drive_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.laser_clean_drive_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.laser_clean_drive_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.laser_clean_drive_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.laser_clean_drive_amplitude.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_readout_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_readout_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_readout_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_readout_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_readout_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_readout_y_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyScan_mode(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.scan_mode'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.laser_align.property.scan_mode.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.laser_align.property.scan_mode.value', bool(new_val))


class RootWorkflowLaser_alignPropertyMotor_beam_shifter_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_beam_shifter_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_beam_shifter_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_beam_shifter_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_beam_shifter_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_beam_shifter_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_speed_laser_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_speed_laser_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_speed_laser_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_speed_laser_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_speed_laser_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_speed_laser_motors.unit', str(new_val))


class RootWorkflowLaser_alignPropertyLaser_clean_drive_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_clean_drive_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.laser_align.property.laser_clean_drive_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.laser_align.property.laser_clean_drive_enabled.value', bool(new_val))


class RootWorkflowLaser_alignPropertyMotor_speed_max_laser_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_speed_max_laser_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_speed_max_laser_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_speed_max_laser_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_speed_max_laser_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_speed_max_laser_motors.unit', str(new_val))


class RootWorkflowLaser_alignPropertyUpdate_detector_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.update_detector_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.update_detector_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.update_detector_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.update_detector_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.update_detector_rate.unit', str(new_val))


class RootWorkflowLaser_alignPropertySensor_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Low = 1
        Fail = 4
        Undefined = 0
        Ok = 2
        High = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.sensor_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowLaser_alignPropertySensor_status.ValueEnum(self._context.get('root.workflow.laser_align.property.sensor_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.laser_align.property.sensor_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.laser_align.property.sensor_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.laser_align.property.sensor_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.laser_align.property.sensor_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.laser_align.property.sensor_status.enum', list(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_photodetector_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_photodetector_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_photodetector_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_photodetector_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_photodetector_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_photodetector_y_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_clean_drive_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_clean_drive_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_clean_drive_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_clean_drive_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_clean_drive_x_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyLaser_readout_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_readout_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.laser_align.property.laser_readout_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.laser_align.property.laser_readout_enabled.value', bool(new_val))


class RootWorkflowLaser_alignPropertyLaser_readout_power(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_readout_power'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.laser_readout_power.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.laser_readout_power.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.laser_readout_power.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.laser_readout_power.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_photodetector_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_photodetector_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_photodetector_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_photodetector_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_photodetector_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_photodetector_x_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyLaser_clean_drive_power(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_clean_drive_power'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.laser_clean_drive_power.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.laser_clean_drive_power.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.laser_clean_drive_power.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.laser_clean_drive_power.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_step(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_step'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_step.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_step.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_step.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_step.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_y_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_clean_drive_y_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_clean_drive_y_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_clean_drive_y_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_clean_drive_y_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_clean_drive_y_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyDeflection_offset_calibration_status(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Calibration_Error = 1
        No_Error = 0
        Sensor_Signal_Failed = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.deflection_offset_calibration_status'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowLaser_alignPropertyDeflection_offset_calibration_status.ValueEnum(self._context.get('root.workflow.laser_align.property.deflection_offset_calibration_status.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.laser_align.property.deflection_offset_calibration_status.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.laser_align.property.deflection_offset_calibration_status.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.laser_align.property.deflection_offset_calibration_status.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.laser_align.property.deflection_offset_calibration_status.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.laser_align.property.deflection_offset_calibration_status.enum', list(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_focus_z_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_focus_z_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_focus_z_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_focus_z_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_focus_z_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_focus_z_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyLaser_spot_intensity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.laser_spot_intensity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.laser_spot_intensity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.laser_spot_intensity.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.laser_spot_intensity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.laser_spot_intensity.unit', str(new_val))


class RootWorkflowLaser_alignPropertyMotor_laser_readout_x_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.motor_laser_readout_x_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.motor_laser_readout_x_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.motor_laser_readout_x_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.motor_laser_readout_x_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.motor_laser_readout_x_position.unit', str(new_val))


class RootWorkflowLaser_alignPropertyDeflection_lateral(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.deflection_lateral'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.deflection_lateral.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.deflection_lateral.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.deflection_lateral.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.deflection_lateral.unit', str(new_val))


class RootWorkflowLaser_alignPropertyDeflection_normal(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property.deflection_normal'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.laser_align.property.deflection_normal.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.laser_align.property.deflection_normal.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.laser_align.property.deflection_normal.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.laser_align.property.deflection_normal.unit', str(new_val))


class RootWorkflowLaser_alignProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align.property'
        self.deflection_normal = RootWorkflowLaser_alignPropertyDeflection_normal(self._context)
        self.deflection_lateral = RootWorkflowLaser_alignPropertyDeflection_lateral(self._context)
        self.motor_laser_readout_x_position = RootWorkflowLaser_alignPropertyMotor_laser_readout_x_position(self._context)
        self.laser_spot_intensity = RootWorkflowLaser_alignPropertyLaser_spot_intensity(self._context)
        self.motor_laser_focus_z_position = RootWorkflowLaser_alignPropertyMotor_laser_focus_z_position(self._context)
        self.deflection_offset_calibration_status = RootWorkflowLaser_alignPropertyDeflection_offset_calibration_status(self._context)
        self.motor_laser_clean_drive_y_position = RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_y_position(self._context)
        self.motor_step = RootWorkflowLaser_alignPropertyMotor_step(self._context)
        self.laser_clean_drive_power = RootWorkflowLaser_alignPropertyLaser_clean_drive_power(self._context)
        self.motor_laser_photodetector_x_position = RootWorkflowLaser_alignPropertyMotor_laser_photodetector_x_position(self._context)
        self.laser_readout_power = RootWorkflowLaser_alignPropertyLaser_readout_power(self._context)
        self.laser_readout_enabled = RootWorkflowLaser_alignPropertyLaser_readout_enabled(self._context)
        self.motor_laser_clean_drive_x_position = RootWorkflowLaser_alignPropertyMotor_laser_clean_drive_x_position(self._context)
        self.motor_laser_photodetector_y_position = RootWorkflowLaser_alignPropertyMotor_laser_photodetector_y_position(self._context)
        self.sensor_status = RootWorkflowLaser_alignPropertySensor_status(self._context)
        self.update_detector_rate = RootWorkflowLaser_alignPropertyUpdate_detector_rate(self._context)
        self.motor_speed_max_laser_motors = RootWorkflowLaser_alignPropertyMotor_speed_max_laser_motors(self._context)
        self.laser_clean_drive_enabled = RootWorkflowLaser_alignPropertyLaser_clean_drive_enabled(self._context)
        self.motor_speed_laser_motors = RootWorkflowLaser_alignPropertyMotor_speed_laser_motors(self._context)
        self.motor_beam_shifter_position = RootWorkflowLaser_alignPropertyMotor_beam_shifter_position(self._context)
        self.scan_mode = RootWorkflowLaser_alignPropertyScan_mode(self._context)
        self.motor_laser_readout_y_position = RootWorkflowLaser_alignPropertyMotor_laser_readout_y_position(self._context)
        self.laser_clean_drive_amplitude = RootWorkflowLaser_alignPropertyLaser_clean_drive_amplitude(self._context)


class RootWorkflowLaser_align(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.laser_align'
        self.property = RootWorkflowLaser_alignProperty(self._context)
        self.signal = RootWorkflowLaser_alignSignal(self._context)

    def is_checking_thermal(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.is_checking_thermal', *args)

    def is_idle(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.is_idle', *args)

    def stop_updating_detector_status(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.stop_updating_detector_status', *args)

    def start_moving_motors(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.start_moving_motors', *args)

    def start_auto_align(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.start_auto_align', *args)

    def stop_motors(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.stop_motors', *args)

    def start_updating_detector_status(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.start_updating_detector_status', *args)

    def adjust_motor_speed(self, *args) -> Any:
        return self._context.call('root.workflow.laser_align.adjust_motor_speed', *args)


class RootWorkflowStorageSignalMeasurement_image_opened(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.signal.measurement_image_opened'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.measurement_image_opened.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.measurement_image_opened.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.measurement_image_opened.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.measurement_image_opened.connect_extended', *args)


class RootWorkflowStorageSignalCurrent_measurement_image_changed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.signal.current_measurement_image_changed'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.current_measurement_image_changed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.current_measurement_image_changed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.current_measurement_image_changed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.storage.signal.current_measurement_image_changed.connect_extended', *args)


class RootWorkflowStorageSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.signal'
        self.current_measurement_image_changed = RootWorkflowStorageSignalCurrent_measurement_image_changed(self._context)
        self.measurement_image_opened = RootWorkflowStorageSignalMeasurement_image_opened(self._context)


class RootWorkflowStoragePropertyNhf_auto_store_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Current_File = 2
        New_File = 1
        Off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.nhf_auto_store_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowStoragePropertyNhf_auto_store_mode.ValueEnum(self._context.get('root.workflow.storage.property.nhf_auto_store_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.storage.property.nhf_auto_store_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.storage.property.nhf_auto_store_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.storage.property.nhf_auto_store_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.storage.property.nhf_auto_store_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.storage.property.nhf_auto_store_mode.enum', list(new_val))


class RootWorkflowStoragePropertyName_pattern(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.name_pattern'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> str:
        return str(self._context.get('root.workflow.storage.property.name_pattern.value'))

    @value.setter
    def value(self, new_val:str):
        self._context.set('root.workflow.storage.property.name_pattern.value', str(new_val))


class RootWorkflowStoragePropertyAuto_save_partial_measurements(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.auto_save_partial_measurements'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.storage.property.auto_save_partial_measurements.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.storage.property.auto_save_partial_measurements.value', bool(new_val))


class RootWorkflowStoragePropertyNidx_auto_store_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Current_File = 2
        New_File = 1
        Off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.nidx_auto_store_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowStoragePropertyNidx_auto_store_mode.ValueEnum(self._context.get('root.workflow.storage.property.nidx_auto_store_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.storage.property.nidx_auto_store_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.storage.property.nidx_auto_store_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.storage.property.nidx_auto_store_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.storage.property.nidx_auto_store_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.storage.property.nidx_auto_store_mode.enum', list(new_val))


class RootWorkflowStoragePropertyGwy_backend_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.gwy_backend_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.storage.property.gwy_backend_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.storage.property.gwy_backend_enabled.value', bool(new_val))


class RootWorkflowStoragePropertyNhf_backend_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.nhf_backend_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.storage.property.nhf_backend_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.storage.property.nhf_backend_enabled.value', bool(new_val))


class RootWorkflowStoragePropertyGallery_directory(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.gallery_directory'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> str:
        return str(self._context.get('root.workflow.storage.property.gallery_directory.value'))

    @value.setter
    def value(self, new_val:str):
        self._context.set('root.workflow.storage.property.gallery_directory.value', str(new_val))


class RootWorkflowStoragePropertyNidx_backend_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.nidx_backend_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.storage.property.nidx_backend_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.storage.property.nidx_backend_enabled.value', bool(new_val))


class RootWorkflowStoragePropertyGwy_auto_store_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Store_to_file = 1
        Off = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property.gwy_auto_store_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowStoragePropertyGwy_auto_store_mode.ValueEnum(self._context.get('root.workflow.storage.property.gwy_auto_store_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.storage.property.gwy_auto_store_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.storage.property.gwy_auto_store_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.storage.property.gwy_auto_store_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.storage.property.gwy_auto_store_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.storage.property.gwy_auto_store_mode.enum', list(new_val))


class RootWorkflowStorageProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage.property'
        self.gwy_auto_store_mode = RootWorkflowStoragePropertyGwy_auto_store_mode(self._context)
        self.nidx_backend_enabled = RootWorkflowStoragePropertyNidx_backend_enabled(self._context)
        self.gallery_directory = RootWorkflowStoragePropertyGallery_directory(self._context)
        self.nhf_backend_enabled = RootWorkflowStoragePropertyNhf_backend_enabled(self._context)
        self.gwy_backend_enabled = RootWorkflowStoragePropertyGwy_backend_enabled(self._context)
        self.nidx_auto_store_mode = RootWorkflowStoragePropertyNidx_auto_store_mode(self._context)
        self.auto_save_partial_measurements = RootWorkflowStoragePropertyAuto_save_partial_measurements(self._context)
        self.name_pattern = RootWorkflowStoragePropertyName_pattern(self._context)
        self.nhf_auto_store_mode = RootWorkflowStoragePropertyNhf_auto_store_mode(self._context)


class RootWorkflowStorage(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.storage'
        self.property = RootWorkflowStorageProperty(self._context)
        self.signal = RootWorkflowStorageSignal(self._context)

    def create_measurement(self, *args) -> Any:
        return self._context.call('root.workflow.storage.create_measurement', *args)

    def close_file(self, *args) -> Any:
        return self._context.call('root.workflow.storage.close_file', *args)

    def open_file(self, *args) -> Any:
        return self._context.call('root.workflow.storage.open_file', *args)


class RootWorkflowSignal_selection(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.signal_selection'


class RootWorkflowImagingSignalScanning_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.scanning_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_finished.connect_extended', *args)


class RootWorkflowImagingSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.procedure_info.connect_extended', *args)


class RootWorkflowImagingSignalRemaining_scan_time_changed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.remaining_scan_time_changed'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.remaining_scan_time_changed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.remaining_scan_time_changed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.remaining_scan_time_changed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.remaining_scan_time_changed.connect_extended', *args)


class RootWorkflowImagingSignalScanning_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.scanning_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_started.connect_extended', *args)


class RootWorkflowImagingSignalScanning_resumed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.scanning_resumed'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_resumed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_resumed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_resumed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_resumed.connect_extended', *args)


class RootWorkflowImagingSignalScanning_paused(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal.scanning_paused'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_paused.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_paused.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_paused.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.signal.scanning_paused.connect_extended', *args)


class RootWorkflowImagingSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.signal'
        self.scanning_paused = RootWorkflowImagingSignalScanning_paused(self._context)
        self.scanning_resumed = RootWorkflowImagingSignalScanning_resumed(self._context)
        self.scanning_started = RootWorkflowImagingSignalScanning_started(self._context)
        self.remaining_scan_time_changed = RootWorkflowImagingSignalRemaining_scan_time_changed(self._context)
        self.procedure_info = RootWorkflowImagingSignalProcedure_info(self._context)
        self.scanning_finished = RootWorkflowImagingSignalScanning_finished(self._context)


class RootWorkflowImagingPropertyImage_offset_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.image_offset_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.image_offset_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.image_offset_y.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.image_offset_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.image_offset_y.unit', str(new_val))


class RootWorkflowImagingPropertyLine_rate(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.line_rate'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.line_rate.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.line_rate.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.line_rate.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.line_rate.unit', str(new_val))


class RootWorkflowImagingPropertyScan_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Continuous = 0
        Single_Frame = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.scan_mode'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowImagingPropertyScan_mode.ValueEnum(self._context.get('root.workflow.imaging.property.scan_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.imaging.property.scan_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.imaging.property.scan_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.imaging.property.scan_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.imaging.property.scan_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.imaging.property.scan_mode.enum', list(new_val))


class RootWorkflowImagingPropertyBackward_points_per_line(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.backward_points_per_line'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.imaging.property.backward_points_per_line.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.imaging.property.backward_points_per_line.value', int(new_val))


class RootWorkflowImagingPropertyPoints_per_line(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.points_per_line'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.imaging.property.points_per_line.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.imaging.property.points_per_line.value', int(new_val))


class RootWorkflowImagingPropertySlow_axis_scan_direction(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Downward = 0
        Upward = 1
        Bounce = 2

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.slow_axis_scan_direction'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowImagingPropertySlow_axis_scan_direction.ValueEnum(self._context.get('root.workflow.imaging.property.slow_axis_scan_direction.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.imaging.property.slow_axis_scan_direction.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.imaging.property.slow_axis_scan_direction.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.imaging.property.slow_axis_scan_direction.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.imaging.property.slow_axis_scan_direction.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.imaging.property.slow_axis_scan_direction.enum', list(new_val))


class RootWorkflowImagingPropertyImage_offset_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.image_offset_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.image_offset_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.image_offset_x.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.image_offset_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.image_offset_x.unit', str(new_val))


class RootWorkflowImagingPropertyFinish_current_frame_and_stop(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.finish_current_frame_and_stop'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.imaging.property.finish_current_frame_and_stop.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.imaging.property.finish_current_frame_and_stop.value', bool(new_val))


class RootWorkflowImagingPropertyTime_per_line(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.time_per_line'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.time_per_line.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.time_per_line.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.time_per_line.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.time_per_line.unit', str(new_val))


class RootWorkflowImagingPropertyLines_per_frame(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.lines_per_frame'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.imaging.property.lines_per_frame.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.imaging.property.lines_per_frame.value', int(new_val))


class RootWorkflowImagingPropertyScan_range_slow_axis(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.scan_range_slow_axis'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.scan_range_slow_axis.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.scan_range_slow_axis.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.scan_range_slow_axis.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.scan_range_slow_axis.unit', str(new_val))


class RootWorkflowImagingPropertyTip_velocity(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.tip_velocity'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.tip_velocity.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.tip_velocity.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.tip_velocity.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.tip_velocity.unit', str(new_val))


class RootWorkflowImagingPropertyRotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.rotation.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.rotation.unit', str(new_val))


class RootWorkflowImagingPropertyMove_speed_xy(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.move_speed_xy'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.move_speed_xy.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.move_speed_xy.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.move_speed_xy.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.move_speed_xy.unit', str(new_val))


class RootWorkflowImagingPropertyOverscan(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.overscan'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.overscan.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.overscan.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.overscan.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.overscan.unit', str(new_val))


class RootWorkflowImagingPropertySlope_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.slope_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.slope_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.slope_y.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.slope_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.slope_y.unit', str(new_val))


class RootWorkflowImagingPropertySlope_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.slope_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.slope_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.slope_x.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.slope_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.slope_x.unit', str(new_val))


class RootWorkflowImagingPropertyScan_range_fast_axis(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property.scan_range_fast_axis'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.imaging.property.scan_range_fast_axis.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.imaging.property.scan_range_fast_axis.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.imaging.property.scan_range_fast_axis.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.imaging.property.scan_range_fast_axis.unit', str(new_val))


class RootWorkflowImagingProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.property'
        self.scan_range_fast_axis = RootWorkflowImagingPropertyScan_range_fast_axis(self._context)
        self.slope_x = RootWorkflowImagingPropertySlope_x(self._context)
        self.slope_y = RootWorkflowImagingPropertySlope_y(self._context)
        self.overscan = RootWorkflowImagingPropertyOverscan(self._context)
        self.move_speed_xy = RootWorkflowImagingPropertyMove_speed_xy(self._context)
        self.rotation = RootWorkflowImagingPropertyRotation(self._context)
        self.tip_velocity = RootWorkflowImagingPropertyTip_velocity(self._context)
        self.scan_range_slow_axis = RootWorkflowImagingPropertyScan_range_slow_axis(self._context)
        self.lines_per_frame = RootWorkflowImagingPropertyLines_per_frame(self._context)
        self.time_per_line = RootWorkflowImagingPropertyTime_per_line(self._context)
        self.finish_current_frame_and_stop = RootWorkflowImagingPropertyFinish_current_frame_and_stop(self._context)
        self.image_offset_x = RootWorkflowImagingPropertyImage_offset_x(self._context)
        self.slow_axis_scan_direction = RootWorkflowImagingPropertySlow_axis_scan_direction(self._context)
        self.points_per_line = RootWorkflowImagingPropertyPoints_per_line(self._context)
        self.backward_points_per_line = RootWorkflowImagingPropertyBackward_points_per_line(self._context)
        self.scan_mode = RootWorkflowImagingPropertyScan_mode(self._context)
        self.line_rate = RootWorkflowImagingPropertyLine_rate(self._context)
        self.image_offset_y = RootWorkflowImagingPropertyImage_offset_y(self._context)


class RootWorkflowImagingVarScript_test_var_array(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.var.script_test_var_array'


class RootWorkflowImagingVar(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging.var'
        self.script_test_var_array = RootWorkflowImagingVarScript_test_var_array(self._context)

    @property
    def script_test_var_int(self) -> int:
        return int(self._context.get('root.workflow.imaging.var.script_test_var_int'))

    @script_test_var_int.setter
    def script_test_var_int(self, new_val:int):
        self._context.set('root.workflow.imaging.var.script_test_var_int', int(new_val))

    @property
    def script_test_var_double(self) -> float:
        return float(self._context.get('root.workflow.imaging.var.script_test_var_double'))

    @script_test_var_double.setter
    def script_test_var_double(self, new_val:float):
        self._context.set('root.workflow.imaging.var.script_test_var_double', float(new_val))

    @property
    def script_test_var_string(self) -> str:
        return str(self._context.get('root.workflow.imaging.var.script_test_var_string'))

    @script_test_var_string.setter
    def script_test_var_string(self, new_val:str):
        self._context.set('root.workflow.imaging.var.script_test_var_string', str(new_val))


class RootWorkflowImaging(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.imaging'
        self.var = RootWorkflowImagingVar(self._context)
        self.property = RootWorkflowImagingProperty(self._context)
        self.signal = RootWorkflowImagingSignal(self._context)

    def stop_imaging(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.stop_imaging', *args)

    def start_imaging(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.start_imaging', *args)

    def is_scanning(self, *args) -> Any:
        return self._context.call('root.workflow.imaging.is_scanning', *args)


class RootWorkflowMode_loader(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.mode_loader'


class RootWorkflowApproachPropertyStep_by_step_slope(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_slope'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach.property.step_by_step_slope.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach.property.step_by_step_slope.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.step_by_step_slope.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.step_by_step_slope.unit', str(new_val))


class RootWorkflowApproachPropertyStep_by_step_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Tip_Position_Ignored = 2
        Not_Controlled = 1
        Position_Controlled = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowApproachPropertyStep_by_step_mode.ValueEnum(self._context.get('root.workflow.approach.property.step_by_step_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.approach.property.step_by_step_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.approach.property.step_by_step_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.approach.property.step_by_step_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.approach.property.step_by_step_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.approach.property.step_by_step_mode.enum', list(new_val))


class RootWorkflowApproachPropertyStep_by_step_time(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_time'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach.property.step_by_step_time.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach.property.step_by_step_time.value', float(new_val))


class RootWorkflowApproachPropertyStep_by_step_fine_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_fine_step_size_percentage'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.approach.property.step_by_step_fine_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.approach.property.step_by_step_fine_step_size_percentage.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.step_by_step_fine_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.step_by_step_fine_step_size_percentage.unit', str(new_val))


class RootWorkflowApproachPropertyStep_by_step_coarse_step_size_percentage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_coarse_step_size_percentage'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.approach.property.step_by_step_coarse_step_size_percentage.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.approach.property.step_by_step_coarse_step_size_percentage.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.step_by_step_coarse_step_size_percentage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.step_by_step_coarse_step_size_percentage.unit', str(new_val))


class RootWorkflowApproachPropertyApproach_pos(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.approach_pos'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach.property.approach_pos.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach.property.approach_pos.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.approach_pos.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.approach_pos.unit', str(new_val))


class RootWorkflowApproachPropertyWithdraw_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.withdraw_steps'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.approach.property.withdraw_steps.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.approach.property.withdraw_steps.value', int(new_val))


class RootWorkflowApproachPropertyApproach_steps(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.approach_steps'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.approach.property.approach_steps.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.approach.property.approach_steps.value', int(new_val))


class RootWorkflowApproachPropertyStep_by_step_approach_result(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_approach_result'
        self._lua_value_type = wrap.LuaType('str')

    @property
    def value(self) -> str:
        return str(self._context.get('root.workflow.approach.property.step_by_step_approach_result.value'))

    @value.setter
    def value(self, new_val:str):
        self._context.set('root.workflow.approach.property.step_by_step_approach_result.value', str(new_val))


class RootWorkflowApproachPropertyStep_by_step_deflection_offset_voltage(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.step_by_step_deflection_offset_voltage'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach.property.step_by_step_deflection_offset_voltage.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach.property.step_by_step_deflection_offset_voltage.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.step_by_step_deflection_offset_voltage.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.step_by_step_deflection_offset_voltage.unit', str(new_val))


class RootWorkflowApproachPropertyApproach_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Continuous = 0
        Step_by_Step = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.approach_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowApproachPropertyApproach_mode.ValueEnum(self._context.get('root.workflow.approach.property.approach_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.approach.property.approach_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.approach.property.approach_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.approach.property.approach_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.approach.property.approach_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.approach.property.approach_mode.enum', list(new_val))


class RootWorkflowApproachPropertyApproach_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.approach_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach.property.approach_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach.property.approach_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach.property.approach_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach.property.approach_speed.unit', str(new_val))


class RootWorkflowApproachPropertyMotor_source(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Internal = 0
        External = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property.motor_source'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowApproachPropertyMotor_source.ValueEnum(self._context.get('root.workflow.approach.property.motor_source.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.approach.property.motor_source.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.approach.property.motor_source.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.approach.property.motor_source.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.approach.property.motor_source.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.approach.property.motor_source.enum', list(new_val))


class RootWorkflowApproachProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.property'
        self.motor_source = RootWorkflowApproachPropertyMotor_source(self._context)
        self.approach_speed = RootWorkflowApproachPropertyApproach_speed(self._context)
        self.approach_mode = RootWorkflowApproachPropertyApproach_mode(self._context)
        self.step_by_step_deflection_offset_voltage = RootWorkflowApproachPropertyStep_by_step_deflection_offset_voltage(self._context)
        self.step_by_step_approach_result = RootWorkflowApproachPropertyStep_by_step_approach_result(self._context)
        self.approach_steps = RootWorkflowApproachPropertyApproach_steps(self._context)
        self.withdraw_steps = RootWorkflowApproachPropertyWithdraw_steps(self._context)
        self.approach_pos = RootWorkflowApproachPropertyApproach_pos(self._context)
        self.step_by_step_coarse_step_size_percentage = RootWorkflowApproachPropertyStep_by_step_coarse_step_size_percentage(self._context)
        self.step_by_step_fine_step_size_percentage = RootWorkflowApproachPropertyStep_by_step_fine_step_size_percentage(self._context)
        self.step_by_step_time = RootWorkflowApproachPropertyStep_by_step_time(self._context)
        self.step_by_step_mode = RootWorkflowApproachPropertyStep_by_step_mode(self._context)
        self.step_by_step_slope = RootWorkflowApproachPropertyStep_by_step_slope(self._context)


class RootWorkflowApproachSignalWithdraw_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal.withdraw_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.withdraw_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.withdraw_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.withdraw_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.withdraw_started.connect_extended', *args)


class RootWorkflowApproachSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.procedure_info.connect_extended', *args)


class RootWorkflowApproachSignalApproach_or_withdraw_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal.approach_or_withdraw_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_or_withdraw_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_or_withdraw_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_or_withdraw_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_or_withdraw_finished.connect_extended', *args)


class RootWorkflowApproachSignalApproach_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal.approach_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach.signal.approach_started.connect_extended', *args)


class RootWorkflowApproachSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach.signal'
        self.approach_started = RootWorkflowApproachSignalApproach_started(self._context)
        self.approach_or_withdraw_finished = RootWorkflowApproachSignalApproach_or_withdraw_finished(self._context)
        self.procedure_info = RootWorkflowApproachSignalProcedure_info(self._context)
        self.withdraw_started = RootWorkflowApproachSignalWithdraw_started(self._context)


class RootWorkflowApproach(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach'
        self.signal = RootWorkflowApproachSignal(self._context)
        self.property = RootWorkflowApproachProperty(self._context)

    def start_approach(self, *args) -> Any:
        return self._context.call('root.workflow.approach.start_approach', *args)

    def stop_approach_or_withdraw(self, *args) -> Any:
        return self._context.call('root.workflow.approach.stop_approach_or_withdraw', *args)

    def start_withdraw(self, *args) -> Any:
        return self._context.call('root.workflow.approach.start_withdraw', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.workflow.approach.abort', *args)


class RootWorkflowOrtSignalOscilloscope_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.oscilloscope_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.oscilloscope_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.oscilloscope_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.oscilloscope_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.oscilloscope_data.connect_extended', *args)


class RootWorkflowOrtSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.procedure_info.connect_extended', *args)


class RootWorkflowOrtSignalUpdating_free_wave(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.updating_free_wave'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave.connect_extended', *args)


class RootWorkflowOrtSignalUpdating_free_wave_done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.updating_free_wave_done'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave_done.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave_done.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave_done.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.updating_free_wave_done.connect_extended', *args)


class RootWorkflowOrtSignalChanging_excitation_done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.changing_excitation_done'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation_done.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation_done.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation_done.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation_done.connect_extended', *args)


class RootWorkflowOrtSignalChanging_excitation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal.changing_excitation'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.ort.signal.changing_excitation.connect_extended', *args)


class RootWorkflowOrtSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.signal'
        self.changing_excitation = RootWorkflowOrtSignalChanging_excitation(self._context)
        self.changing_excitation_done = RootWorkflowOrtSignalChanging_excitation_done(self._context)
        self.updating_free_wave_done = RootWorkflowOrtSignalUpdating_free_wave_done(self._context)
        self.updating_free_wave = RootWorkflowOrtSignalUpdating_free_wave(self._context)
        self.procedure_info = RootWorkflowOrtSignalProcedure_info(self._context)
        self.oscilloscope_data = RootWorkflowOrtSignalOscilloscope_data(self._context)


class RootWorkflowOrtPropertyCantilever_samples_per_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.cantilever_samples_per_period'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.ort.property.cantilever_samples_per_period.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.ort.property.cantilever_samples_per_period.value', int(new_val))


class RootWorkflowOrtPropertyFree_wave_delay(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.free_wave_delay'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.free_wave_delay.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.free_wave_delay.value', float(new_val))


class RootWorkflowOrtPropertyLift_height(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.lift_height'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.lift_height.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.lift_height.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.lift_height.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.lift_height.unit', str(new_val))


class RootWorkflowOrtPropertyExcitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.excitation_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.excitation_amplitude.unit', str(new_val))


class RootWorkflowOrtPropertyBaseline_window_end(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_window_end'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.baseline_window_end.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.baseline_window_end.value', float(new_val))


class RootWorkflowOrtPropertyAverage_periods(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.average_periods'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.ort.property.average_periods.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.ort.property.average_periods.value', int(new_val))


class RootWorkflowOrtPropertyBaseline_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.baseline_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.baseline_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.baseline_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.baseline_value.unit', str(new_val))


class RootWorkflowOrtPropertyFeedback_amplitude_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.feedback_amplitude_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.feedback_amplitude_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.feedback_amplitude_position.value', float(new_val))


class RootWorkflowOrtPropertyBaseline_window_begin(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_window_begin'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.baseline_window_begin.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.baseline_window_begin.value', float(new_val))


class RootWorkflowOrtPropertyBaseline_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.baseline_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.baseline_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.baseline_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.baseline_frequency.unit', str(new_val))


class RootWorkflowOrtPropertyAdhesion_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.adhesion_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.adhesion_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.adhesion_position.value', float(new_val))


class RootWorkflowOrtPropertyAmplitude_reduction(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.amplitude_reduction'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.amplitude_reduction.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.amplitude_reduction.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.amplitude_reduction.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.amplitude_reduction.unit', str(new_val))


class RootWorkflowOrtPropertySamples_per_period(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.samples_per_period'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.ort.property.samples_per_period.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.ort.property.samples_per_period.value', int(new_val))


class RootWorkflowOrtPropertyAdhesion_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.adhesion_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.adhesion_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.adhesion_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.adhesion_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.adhesion_value.unit', str(new_val))


class RootWorkflowOrtPropertyInput_select(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Fast_In_User = 2
        Fast_In_Deflection = 0
        Hi_Res_In_User1 = 3
        Hi_Res_In_Deflection = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.input_select'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowOrtPropertyInput_select.ValueEnum(self._context.get('root.workflow.ort.property.input_select.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.ort.property.input_select.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.ort.property.input_select.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.ort.property.input_select.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.ort.property.input_select.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.ort.property.input_select.enum', list(new_val))


class RootWorkflowOrtPropertyWave_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.wave_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.wave_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.wave_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.wave_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.wave_amplitude.unit', str(new_val))


class RootWorkflowOrtPropertyWave_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.wave_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.wave_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.wave_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.wave_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.wave_frequency.unit', str(new_val))


class RootWorkflowOrtPropertyBaseline_controller_enabled(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_controller_enabled'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.ort.property.baseline_controller_enabled.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.ort.property.baseline_controller_enabled.value', bool(new_val))


class RootWorkflowOrtPropertyBaseline_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property.baseline_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.ort.property.baseline_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.ort.property.baseline_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.ort.property.baseline_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.ort.property.baseline_amplitude.unit', str(new_val))


class RootWorkflowOrtProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort.property'
        self.baseline_amplitude = RootWorkflowOrtPropertyBaseline_amplitude(self._context)
        self.baseline_controller_enabled = RootWorkflowOrtPropertyBaseline_controller_enabled(self._context)
        self.wave_frequency = RootWorkflowOrtPropertyWave_frequency(self._context)
        self.wave_amplitude = RootWorkflowOrtPropertyWave_amplitude(self._context)
        self.input_select = RootWorkflowOrtPropertyInput_select(self._context)
        self.adhesion_value = RootWorkflowOrtPropertyAdhesion_value(self._context)
        self.samples_per_period = RootWorkflowOrtPropertySamples_per_period(self._context)
        self.amplitude_reduction = RootWorkflowOrtPropertyAmplitude_reduction(self._context)
        self.adhesion_position = RootWorkflowOrtPropertyAdhesion_position(self._context)
        self.baseline_frequency = RootWorkflowOrtPropertyBaseline_frequency(self._context)
        self.baseline_window_begin = RootWorkflowOrtPropertyBaseline_window_begin(self._context)
        self.feedback_amplitude_position = RootWorkflowOrtPropertyFeedback_amplitude_position(self._context)
        self.baseline_value = RootWorkflowOrtPropertyBaseline_value(self._context)
        self.average_periods = RootWorkflowOrtPropertyAverage_periods(self._context)
        self.baseline_window_end = RootWorkflowOrtPropertyBaseline_window_end(self._context)
        self.excitation_amplitude = RootWorkflowOrtPropertyExcitation_amplitude(self._context)
        self.lift_height = RootWorkflowOrtPropertyLift_height(self._context)
        self.free_wave_delay = RootWorkflowOrtPropertyFree_wave_delay(self._context)
        self.cantilever_samples_per_period = RootWorkflowOrtPropertyCantilever_samples_per_period(self._context)


class RootWorkflowOrt(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.ort'
        self.property = RootWorkflowOrtProperty(self._context)
        self.signal = RootWorkflowOrtSignal(self._context)

    def update_excitation(self, *args) -> Any:
        return self._context.call('root.workflow.ort.update_excitation', *args)

    def update_free_wave(self, *args) -> Any:
        return self._context.call('root.workflow.ort.update_free_wave', *args)

    def wait_for_async_sm_tasks_to_finish(self, *args) -> Any:
        return self._context.call('root.workflow.ort.wait_for_async_sm_tasks_to_finish', *args)


class RootWorkflowManager(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.manager'

    @property
    def session_name(self) -> str:
        return str(self._context.get('root.workflow.manager.session_name'))

    @session_name.setter
    def session_name(self, new_val:str):
        self._context.set('root.workflow.manager.session_name', str(new_val))


class RootWorkflowComp_dcPropertyCrosstalk_calibration_ok(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.comp_dc.property.crosstalk_calibration_ok'
        self._lua_value_type = wrap.LuaType('bool')

    @property
    def value(self) -> bool:
        return bool(self._context.get('root.workflow.comp_dc.property.crosstalk_calibration_ok.value'))

    @value.setter
    def value(self, new_val:bool):
        self._context.set('root.workflow.comp_dc.property.crosstalk_calibration_ok.value', bool(new_val))


class RootWorkflowComp_dcProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.comp_dc.property'
        self.crosstalk_calibration_ok = RootWorkflowComp_dcPropertyCrosstalk_calibration_ok(self._context)


class RootWorkflowComp_dc(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.comp_dc'
        self.property = RootWorkflowComp_dcProperty(self._context)

    def start_crosstalk_calibration(self, *args) -> Any:
        return self._context.call('root.workflow.comp_dc.start_crosstalk_calibration', *args)


class RootWorkflowSpectroscopyPropertyMap_rotation(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_rotation'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.map_rotation.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.map_rotation.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_rotation.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_rotation.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyPoint_offset_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.point_offset_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.point_offset_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.point_offset_y.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.point_offset_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.point_offset_y.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_points_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_points_y'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.spectroscopy.property.map_points_y.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.spectroscopy.property.map_points_y.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_points_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_points_y.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_end_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_end_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.map_end_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.map_end_x.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_end_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_end_x.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_end_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_end_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.map_end_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.map_end_y.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_end_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_end_y.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_start_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_start_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.map_start_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.map_start_x.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_start_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_start_x.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_points_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_points_x'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.spectroscopy.property.map_points_x.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.spectroscopy.property.map_points_x.value', int(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_points_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_points_x.unit', str(new_val))


class RootWorkflowSpectroscopyPropertySpecmap_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Map = 1
        Point = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.specmap_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowSpectroscopyPropertySpecmap_mode.ValueEnum(self._context.get('root.workflow.spectroscopy.property.specmap_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.spectroscopy.property.specmap_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.spectroscopy.property.specmap_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.spectroscopy.property.specmap_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.spectroscopy.property.specmap_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.spectroscopy.property.specmap_mode.enum', list(new_val))


class RootWorkflowSpectroscopyPropertyPoint_offset_x(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.point_offset_x'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.point_offset_x.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.point_offset_x.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.point_offset_x.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.point_offset_x.unit', str(new_val))


class RootWorkflowSpectroscopyPropertyMap_start_y(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property.map_start_y'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.spectroscopy.property.map_start_y.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.spectroscopy.property.map_start_y.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.spectroscopy.property.map_start_y.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.spectroscopy.property.map_start_y.unit', str(new_val))


class RootWorkflowSpectroscopyProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy.property'
        self.map_start_y = RootWorkflowSpectroscopyPropertyMap_start_y(self._context)
        self.point_offset_x = RootWorkflowSpectroscopyPropertyPoint_offset_x(self._context)
        self.specmap_mode = RootWorkflowSpectroscopyPropertySpecmap_mode(self._context)
        self.map_points_x = RootWorkflowSpectroscopyPropertyMap_points_x(self._context)
        self.map_start_x = RootWorkflowSpectroscopyPropertyMap_start_x(self._context)
        self.map_end_y = RootWorkflowSpectroscopyPropertyMap_end_y(self._context)
        self.map_end_x = RootWorkflowSpectroscopyPropertyMap_end_x(self._context)
        self.map_points_y = RootWorkflowSpectroscopyPropertyMap_points_y(self._context)
        self.point_offset_y = RootWorkflowSpectroscopyPropertyPoint_offset_y(self._context)
        self.map_rotation = RootWorkflowSpectroscopyPropertyMap_rotation(self._context)


class RootWorkflowSpectroscopy(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy'
        self.property = RootWorkflowSpectroscopyProperty(self._context)


class RootWorkflowShared_data_cache(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.shared_data_cache'


class RootWorkflowWorkflow_spectroscopy_setupSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_spectroscopy_setup.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.signal.procedure_info.connect_extended', *args)


class RootWorkflowWorkflow_spectroscopy_setupSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_spectroscopy_setup.signal'
        self.procedure_info = RootWorkflowWorkflow_spectroscopy_setupSignalProcedure_info(self._context)


class RootWorkflowWorkflow_spectroscopy_setup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_spectroscopy_setup'
        self.signal = RootWorkflowWorkflow_spectroscopy_setupSignal(self._context)

    def create_stress_relaxation_experiment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.create_stress_relaxation_experiment', *args)

    def add_new_segment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.add_new_segment', *args)

    def create_f_d_curve_experiment(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_spectroscopy_setup.create_f_d_curve_experiment', *args)


class RootWorkflowSpectroscopy_view(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spectroscopy_view'


class RootWorkflowSystem_startup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.system_startup'


class RootWorkflowWorkflow_auto_setup(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_auto_setup'

    def auto_setup_stop(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_auto_setup.auto_setup_stop', *args)

    def auto_setup_start(self, *args) -> Any:
        return self._context.call('root.workflow.workflow_auto_setup.auto_setup_start', *args)


class RootWorkflowSpm_resource_requester(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.spm_resource_requester'


class RootWorkflowWorkflow_monitoring(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_monitoring'


class RootWorkflowWorkflow_options(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workflow_options'


class RootWorkflowParameters(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.parameters'


class RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Below_Peak = 0
        Above_Peak = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.frequency_selection_criteria'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria.ValueEnum(self._context.get('root.workflow.frequency_sweep.property.frequency_selection_criteria.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.frequency_sweep.property.frequency_selection_criteria.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.frequency_sweep.property.frequency_selection_criteria.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.frequency_sweep.property.frequency_selection_criteria.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.frequency_sweep.property.frequency_selection_criteria.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.frequency_sweep.property.frequency_selection_criteria.enum', list(new_val))


class RootWorkflowFrequency_sweepPropertyNew_spring_constant(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.new_spring_constant'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.new_spring_constant.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.new_spring_constant.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.new_spring_constant.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.new_spring_constant.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertyAmplitude_unit(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Volts_V_ = 1
        Meters_m_ = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.amplitude_unit'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowFrequency_sweepPropertyAmplitude_unit.ValueEnum(self._context.get('root.workflow.frequency_sweep.property.amplitude_unit.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_unit.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.frequency_sweep.property.amplitude_unit.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_unit.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.frequency_sweep.property.amplitude_unit.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_unit.enum', list(new_val))


class RootWorkflowFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        num_360_Hz = 5
        num_12_kHz = 10
        num_180_Hz = 4
        num_230_kHz = 14
        num_500_kHz = 15
        num_1500_Hz = 7
        num_750_Hz = 6
        num_100_kHz = 13
        num_3_kHz = 8
        num_23_kHz = 11
        num_45_kHz = 12
        num_6_kHz = 9
        num_90_Hz = 3

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowFrequency_sweepPropertyAnalyzer_demodulator_bandwidth.ValueEnum(self._context.get('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.frequency_sweep.property.analyzer_demodulator_bandwidth.enum', list(new_val))


class RootWorkflowFrequency_sweepPropertySweep_data_points(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.sweep_data_points'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.frequency_sweep.property.sweep_data_points.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.frequency_sweep.property.sweep_data_points.value', int(new_val))


class RootWorkflowFrequency_sweepPropertyAmplitude_reduction(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.amplitude_reduction'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.amplitude_reduction.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_reduction.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.amplitude_reduction.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.amplitude_reduction.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertyNew_excitation_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.new_excitation_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.new_excitation_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.new_excitation_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.new_excitation_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.new_excitation_frequency.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertySweep_free_vibration_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.sweep_free_vibration_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.sweep_free_vibration_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.sweep_free_vibration_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.sweep_free_vibration_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.sweep_free_vibration_amplitude.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertySweep_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.sweep_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.sweep_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.sweep_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.sweep_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.sweep_frequency_lower_bound.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertyFit_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.fit_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.fit_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.fit_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.fit_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.fit_frequency_lower_bound.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertySweep_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.sweep_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.sweep_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.sweep_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.sweep_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.sweep_frequency_upper_bound.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertySweep_excitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.sweep_excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.sweep_excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.sweep_excitation_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.sweep_excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.sweep_excitation_amplitude.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertyFit_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.fit_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.frequency_sweep.property.fit_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.frequency_sweep.property.fit_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.frequency_sweep.property.fit_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.frequency_sweep.property.fit_frequency_upper_bound.unit', str(new_val))


class RootWorkflowFrequency_sweepPropertyMeasurement_environment(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Air = 0
        Liquid = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property.measurement_environment'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowFrequency_sweepPropertyMeasurement_environment.ValueEnum(self._context.get('root.workflow.frequency_sweep.property.measurement_environment.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.frequency_sweep.property.measurement_environment.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.frequency_sweep.property.measurement_environment.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.frequency_sweep.property.measurement_environment.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.frequency_sweep.property.measurement_environment.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.frequency_sweep.property.measurement_environment.enum', list(new_val))


class RootWorkflowFrequency_sweepProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.property'
        self.measurement_environment = RootWorkflowFrequency_sweepPropertyMeasurement_environment(self._context)
        self.fit_frequency_upper_bound = RootWorkflowFrequency_sweepPropertyFit_frequency_upper_bound(self._context)
        self.sweep_excitation_amplitude = RootWorkflowFrequency_sweepPropertySweep_excitation_amplitude(self._context)
        self.sweep_frequency_upper_bound = RootWorkflowFrequency_sweepPropertySweep_frequency_upper_bound(self._context)
        self.fit_frequency_lower_bound = RootWorkflowFrequency_sweepPropertyFit_frequency_lower_bound(self._context)
        self.sweep_frequency_lower_bound = RootWorkflowFrequency_sweepPropertySweep_frequency_lower_bound(self._context)
        self.sweep_free_vibration_amplitude = RootWorkflowFrequency_sweepPropertySweep_free_vibration_amplitude(self._context)
        self.new_excitation_frequency = RootWorkflowFrequency_sweepPropertyNew_excitation_frequency(self._context)
        self.amplitude_reduction = RootWorkflowFrequency_sweepPropertyAmplitude_reduction(self._context)
        self.sweep_data_points = RootWorkflowFrequency_sweepPropertySweep_data_points(self._context)
        self.analyzer_demodulator_bandwidth = RootWorkflowFrequency_sweepPropertyAnalyzer_demodulator_bandwidth(self._context)
        self.amplitude_unit = RootWorkflowFrequency_sweepPropertyAmplitude_unit(self._context)
        self.new_spring_constant = RootWorkflowFrequency_sweepPropertyNew_spring_constant(self._context)
        self.frequency_selection_criteria = RootWorkflowFrequency_sweepPropertyFrequency_selection_criteria(self._context)


class RootWorkflowFrequency_sweepSignalNew_fit_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.new_fit_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_fit_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_fit_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_fit_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_fit_data.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalNew_sweep_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.new_sweep_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_sweep_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_sweep_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_sweep_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.new_sweep_data.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.procedure_info.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalSho_fit_failed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.sho_fit_failed'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sho_fit_failed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sho_fit_failed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sho_fit_failed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sho_fit_failed.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalData_invalidated(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.data_invalidated'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.data_invalidated.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.data_invalidated.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.data_invalidated.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.data_invalidated.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalStarted(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.started.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalEnded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.ended'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.ended.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.ended.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.ended.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.ended.connect_extended', *args)


class RootWorkflowFrequency_sweepSignalSweep_progress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal.sweep_progress'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sweep_progress.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sweep_progress.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sweep_progress.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.signal.sweep_progress.connect_extended', *args)


class RootWorkflowFrequency_sweepSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep.signal'
        self.sweep_progress = RootWorkflowFrequency_sweepSignalSweep_progress(self._context)
        self.ended = RootWorkflowFrequency_sweepSignalEnded(self._context)
        self.started = RootWorkflowFrequency_sweepSignalStarted(self._context)
        self.data_invalidated = RootWorkflowFrequency_sweepSignalData_invalidated(self._context)
        self.sho_fit_failed = RootWorkflowFrequency_sweepSignalSho_fit_failed(self._context)
        self.procedure_info = RootWorkflowFrequency_sweepSignalProcedure_info(self._context)
        self.new_sweep_data = RootWorkflowFrequency_sweepSignalNew_sweep_data(self._context)
        self.new_fit_data = RootWorkflowFrequency_sweepSignalNew_fit_data(self._context)


class RootWorkflowFrequency_sweep(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.frequency_sweep'
        self.signal = RootWorkflowFrequency_sweepSignal(self._context)
        self.property = RootWorkflowFrequency_sweepProperty(self._context)

    def start(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.start', *args)

    def process_sweep_data(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.process_sweep_data', *args)

    def apply(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.apply', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.workflow.frequency_sweep.abort', *args)


class RootWorkflowXy_closed_loop(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.xy_closed_loop'


class RootWorkflowZ_controllerPropertyActual_feedback_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.actual_feedback_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.z_controller.property.actual_feedback_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.z_controller.property.actual_feedback_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.z_controller.property.actual_feedback_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.actual_feedback_value.unit', str(new_val))


class RootWorkflowZ_controllerPropertyD_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.d_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.z_controller.property.d_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.z_controller.property.d_gain.value', int(new_val))


class RootWorkflowZ_controllerPropertySetpoint(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.setpoint'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.z_controller.property.setpoint.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.z_controller.property.setpoint.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.z_controller.property.setpoint.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.setpoint.unit', str(new_val))


class RootWorkflowZ_controllerPropertyI_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.i_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.z_controller.property.i_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.z_controller.property.i_gain.value', int(new_val))


class RootWorkflowZ_controllerPropertyP_gain(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.p_gain'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.z_controller.property.p_gain.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.z_controller.property.p_gain.value', int(new_val))


class RootWorkflowZ_controllerPropertyActual_tip_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.actual_tip_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.z_controller.property.actual_tip_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.z_controller.property.actual_tip_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.z_controller.property.actual_tip_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.actual_tip_position.unit', str(new_val))


class RootWorkflowZ_controllerPropertyAbsolute_idle_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.absolute_idle_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.z_controller.property.absolute_idle_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.z_controller.property.absolute_idle_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.z_controller.property.absolute_idle_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.absolute_idle_position.unit', str(new_val))


class RootWorkflowZ_controllerPropertyIdle_mode(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Keep_Last_Z_Position = 2
        Retract_Tip = 1
        Absolute_Z_Position = 3
        Enable_Z_Controller = 0

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.idle_mode'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowZ_controllerPropertyIdle_mode.ValueEnum(self._context.get('root.workflow.z_controller.property.idle_mode.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.z_controller.property.idle_mode.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.z_controller.property.idle_mode.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.z_controller.property.idle_mode.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.z_controller.property.idle_mode.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.z_controller.property.idle_mode.enum', list(new_val))


class RootWorkflowZ_controllerPropertyFeedback(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Deflection = 0
        Dynamic_Mode_Amplitude_Reduction = 2
        WaveMode_Amplitude_Reduction = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.feedback'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowZ_controllerPropertyFeedback.ValueEnum(self._context.get('root.workflow.z_controller.property.feedback.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.z_controller.property.feedback.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.z_controller.property.feedback.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.z_controller.property.feedback.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.z_controller.property.feedback.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.z_controller.property.feedback.enum', list(new_val))


class RootWorkflowZ_controllerPropertyMin_z_value(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property.min_z_value'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.z_controller.property.min_z_value.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.z_controller.property.min_z_value.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.z_controller.property.min_z_value.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.z_controller.property.min_z_value.unit', str(new_val))


class RootWorkflowZ_controllerProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.property'
        self.min_z_value = RootWorkflowZ_controllerPropertyMin_z_value(self._context)
        self.feedback = RootWorkflowZ_controllerPropertyFeedback(self._context)
        self.idle_mode = RootWorkflowZ_controllerPropertyIdle_mode(self._context)
        self.absolute_idle_position = RootWorkflowZ_controllerPropertyAbsolute_idle_position(self._context)
        self.actual_tip_position = RootWorkflowZ_controllerPropertyActual_tip_position(self._context)
        self.p_gain = RootWorkflowZ_controllerPropertyP_gain(self._context)
        self.i_gain = RootWorkflowZ_controllerPropertyI_gain(self._context)
        self.setpoint = RootWorkflowZ_controllerPropertySetpoint(self._context)
        self.d_gain = RootWorkflowZ_controllerPropertyD_gain(self._context)
        self.actual_feedback_value = RootWorkflowZ_controllerPropertyActual_feedback_value(self._context)


class RootWorkflowZ_controllerSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller.signal'


class RootWorkflowZ_controller(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.z_controller'
        self.signal = RootWorkflowZ_controllerSignal(self._context)
        self.property = RootWorkflowZ_controllerProperty(self._context)

    def retracted_do(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.retracted_do', *args)

    def retract_tip(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.retract_tip', *args)

    def tip_position_lower_limit(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.tip_position_lower_limit', *args)

    def setpoint_limits_from_calibration(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.setpoint_limits_from_calibration', *args)

    def setpoint_upper_limit(self, *args) -> Any:
        return self._context.call('root.workflow.z_controller.setpoint_upper_limit', *args)


class RootWorkflowApproach_motorsSignalMotor_move_finished(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.signal.motor_move_finished'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_finished.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_finished.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_finished.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_finished.connect_extended', *args)


class RootWorkflowApproach_motorsSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.procedure_info.connect_extended', *args)


class RootWorkflowApproach_motorsSignalMotor_move_started(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.signal.motor_move_started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.signal.motor_move_started.connect_extended', *args)


class RootWorkflowApproach_motorsSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.signal'
        self.motor_move_started = RootWorkflowApproach_motorsSignalMotor_move_started(self._context)
        self.procedure_info = RootWorkflowApproach_motorsSignalProcedure_info(self._context)
        self.motor_move_finished = RootWorkflowApproach_motorsSignalMotor_move_finished(self._context)


class RootWorkflowApproach_motorsPropertyMotor_speed_advance_retract(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_speed_advance_retract'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_speed_advance_retract.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_speed_advance_retract.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_speed_advance_retract.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_speed_advance_retract.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_speed_approach_motors(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_speed_approach_motors'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_speed_approach_motors.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_speed_approach_motors.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_speed_approach_motors.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_speed_approach_motors.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_right_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_right_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_right_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_right_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_right_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_right_position.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyRelative_tip_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.relative_tip_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.relative_tip_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.relative_tip_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.relative_tip_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.relative_tip_position.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_front_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_front_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_front_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_front_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_front_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_front_position.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_left_position(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_left_position'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_left_position.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_left_position.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_left_position.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_left_position.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_step(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_step'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_step.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_step.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_step.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_step.unit', str(new_val))


class RootWorkflowApproach_motorsPropertyMotor_speed(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property.motor_speed'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.approach_motors.property.motor_speed.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.approach_motors.property.motor_speed.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.approach_motors.property.motor_speed.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.approach_motors.property.motor_speed.unit', str(new_val))


class RootWorkflowApproach_motorsProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors.property'
        self.motor_speed = RootWorkflowApproach_motorsPropertyMotor_speed(self._context)
        self.motor_step = RootWorkflowApproach_motorsPropertyMotor_step(self._context)
        self.motor_left_position = RootWorkflowApproach_motorsPropertyMotor_left_position(self._context)
        self.motor_front_position = RootWorkflowApproach_motorsPropertyMotor_front_position(self._context)
        self.relative_tip_position = RootWorkflowApproach_motorsPropertyRelative_tip_position(self._context)
        self.motor_right_position = RootWorkflowApproach_motorsPropertyMotor_right_position(self._context)
        self.motor_speed_approach_motors = RootWorkflowApproach_motorsPropertyMotor_speed_approach_motors(self._context)
        self.motor_speed_advance_retract = RootWorkflowApproach_motorsPropertyMotor_speed_advance_retract(self._context)


class RootWorkflowApproach_motors(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.approach_motors'
        self.property = RootWorkflowApproach_motorsProperty(self._context)
        self.signal = RootWorkflowApproach_motorsSignal(self._context)

    def stop_motors(self, *args) -> Any:
        return self._context.call('root.workflow.approach_motors.stop_motors', *args)


class RootWorkflowDynamicSignalUpdate_free_vibration_amplitude(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal.update_free_vibration_amplitude'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.update_free_vibration_amplitude.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.update_free_vibration_amplitude.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.update_free_vibration_amplitude.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.update_free_vibration_amplitude.connect_extended', *args)


class RootWorkflowDynamicSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.procedure_info.connect_extended', *args)


class RootWorkflowDynamicSignalUpdating_free_amplitude_done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal.updating_free_amplitude_done'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.updating_free_amplitude_done.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.updating_free_amplitude_done.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.updating_free_amplitude_done.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.updating_free_amplitude_done.connect_extended', *args)


class RootWorkflowDynamicSignalChanging_excitation_done(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal.changing_excitation_done'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation_done.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation_done.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation_done.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation_done.connect_extended', *args)


class RootWorkflowDynamicSignalChanging_excitation(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal.changing_excitation'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.signal.changing_excitation.connect_extended', *args)


class RootWorkflowDynamicSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.signal'
        self.changing_excitation = RootWorkflowDynamicSignalChanging_excitation(self._context)
        self.changing_excitation_done = RootWorkflowDynamicSignalChanging_excitation_done(self._context)
        self.updating_free_amplitude_done = RootWorkflowDynamicSignalUpdating_free_amplitude_done(self._context)
        self.procedure_info = RootWorkflowDynamicSignalProcedure_info(self._context)
        self.update_free_vibration_amplitude = RootWorkflowDynamicSignalUpdate_free_vibration_amplitude(self._context)


class RootWorkflowDynamicPropertyLift_height(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property.lift_height'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.dynamic.property.lift_height.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.dynamic.property.lift_height.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.dynamic.property.lift_height.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.dynamic.property.lift_height.unit', str(new_val))


class RootWorkflowDynamicPropertyFree_vibration_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property.free_vibration_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.dynamic.property.free_vibration_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.dynamic.property.free_vibration_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.dynamic.property.free_vibration_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.dynamic.property.free_vibration_amplitude.unit', str(new_val))


class RootWorkflowDynamicPropertyExcitation_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property.excitation_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.dynamic.property.excitation_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.dynamic.property.excitation_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.dynamic.property.excitation_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.dynamic.property.excitation_frequency.unit', str(new_val))


class RootWorkflowDynamicPropertyReference_phase(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property.reference_phase'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.dynamic.property.reference_phase.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.dynamic.property.reference_phase.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.dynamic.property.reference_phase.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.dynamic.property.reference_phase.unit', str(new_val))


class RootWorkflowDynamicPropertyExcitation_amplitude(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property.excitation_amplitude'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.dynamic.property.excitation_amplitude.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.dynamic.property.excitation_amplitude.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.dynamic.property.excitation_amplitude.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.dynamic.property.excitation_amplitude.unit', str(new_val))


class RootWorkflowDynamicProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic.property'
        self.excitation_amplitude = RootWorkflowDynamicPropertyExcitation_amplitude(self._context)
        self.reference_phase = RootWorkflowDynamicPropertyReference_phase(self._context)
        self.excitation_frequency = RootWorkflowDynamicPropertyExcitation_frequency(self._context)
        self.free_vibration_amplitude = RootWorkflowDynamicPropertyFree_vibration_amplitude(self._context)
        self.lift_height = RootWorkflowDynamicPropertyLift_height(self._context)


class RootWorkflowDynamic(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.dynamic'
        self.property = RootWorkflowDynamicProperty(self._context)
        self.signal = RootWorkflowDynamicSignal(self._context)

    def update_excitation(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.update_excitation', *args)

    def wait_for_async_sm_tasks_to_finish(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.wait_for_async_sm_tasks_to_finish', *args)

    def update_free_vibration_amplitude(self, *args) -> Any:
        return self._context.call('root.workflow.dynamic.update_free_vibration_amplitude', *args)


class RootWorkflowThermal_tunePropertyMeasurement_environment(wrap.CmdTreeProp):

    class ValueEnum(enum.Enum):
        Air = 0
        Liquid = 1

    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.measurement_environment'
        self._lua_value_type = wrap.LuaType('list')

    @property
    def value(self) -> ValueEnum:
        return RootWorkflowThermal_tunePropertyMeasurement_environment.ValueEnum(self._context.get('root.workflow.thermal_tune.property.measurement_environment.value_raw'))

    @value.setter
    def value(self, new_val:ValueEnum):
        self._context.set('root.workflow.thermal_tune.property.measurement_environment.value_raw', new_val.value)

    @property
    def value_raw(self) -> int:
        return int(self._context.get('root.workflow.thermal_tune.property.measurement_environment.value_raw'))

    @value_raw.setter
    def value_raw(self, new_val:int):
        self._context.set('root.workflow.thermal_tune.property.measurement_environment.value_raw', int(new_val))

    @property
    def enum(self) -> list:
        return list(self._context.get('root.workflow.thermal_tune.property.measurement_environment.enum'))

    @enum.setter
    def enum(self, new_val:list):
        self._context.set('root.workflow.thermal_tune.property.measurement_environment.enum', list(new_val))


class RootWorkflowThermal_tunePropertyFit_frequency_lower_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.fit_frequency_lower_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.thermal_tune.property.fit_frequency_lower_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.thermal_tune.property.fit_frequency_lower_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.thermal_tune.property.fit_frequency_lower_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.thermal_tune.property.fit_frequency_lower_bound.unit', str(new_val))


class RootWorkflowThermal_tunePropertyTemperature(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.temperature'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.thermal_tune.property.temperature.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.thermal_tune.property.temperature.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.thermal_tune.property.temperature.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.thermal_tune.property.temperature.unit', str(new_val))


class RootWorkflowThermal_tunePropertyIterations(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.iterations'
        self._lua_value_type = wrap.LuaType('int')

    @property
    def value(self) -> int:
        return int(self._context.get('root.workflow.thermal_tune.property.iterations.value'))

    @value.setter
    def value(self, new_val:int):
        self._context.set('root.workflow.thermal_tune.property.iterations.value', int(new_val))


class RootWorkflowThermal_tunePropertyResolution(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.resolution'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.thermal_tune.property.resolution.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.thermal_tune.property.resolution.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.thermal_tune.property.resolution.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.thermal_tune.property.resolution.unit', str(new_val))


class RootWorkflowThermal_tunePropertyFit_frequency_upper_bound(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.fit_frequency_upper_bound'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.thermal_tune.property.fit_frequency_upper_bound.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.thermal_tune.property.fit_frequency_upper_bound.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.thermal_tune.property.fit_frequency_upper_bound.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.thermal_tune.property.fit_frequency_upper_bound.unit', str(new_val))


class RootWorkflowThermal_tunePropertyMax_frequency(wrap.CmdTreeProp):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property.max_frequency'
        self._lua_value_type = wrap.LuaType('float')

    @property
    def value(self) -> float:
        return float(self._context.get('root.workflow.thermal_tune.property.max_frequency.value'))

    @value.setter
    def value(self, new_val:float):
        self._context.set('root.workflow.thermal_tune.property.max_frequency.value', float(new_val))

    @property
    def unit(self) -> str:
        return str(self._context.get('root.workflow.thermal_tune.property.max_frequency.unit'))

    @unit.setter
    def unit(self, new_val:str):
        self._context.set('root.workflow.thermal_tune.property.max_frequency.unit', str(new_val))


class RootWorkflowThermal_tuneProperty(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.property'
        self.max_frequency = RootWorkflowThermal_tunePropertyMax_frequency(self._context)
        self.fit_frequency_upper_bound = RootWorkflowThermal_tunePropertyFit_frequency_upper_bound(self._context)
        self.resolution = RootWorkflowThermal_tunePropertyResolution(self._context)
        self.iterations = RootWorkflowThermal_tunePropertyIterations(self._context)
        self.temperature = RootWorkflowThermal_tunePropertyTemperature(self._context)
        self.fit_frequency_lower_bound = RootWorkflowThermal_tunePropertyFit_frequency_lower_bound(self._context)
        self.measurement_environment = RootWorkflowThermal_tunePropertyMeasurement_environment(self._context)


class RootWorkflowThermal_tuneSignalNew_calibration_data(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.new_calibration_data'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_calibration_data.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_calibration_data.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_calibration_data.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_calibration_data.connect_extended', *args)


class RootWorkflowThermal_tuneSignalProcedure_info(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.procedure_info'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.procedure_info.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.procedure_info.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.procedure_info.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.procedure_info.connect_extended', *args)


class RootWorkflowThermal_tuneSignalStarted(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.started'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.started.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.started.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.started.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.started.connect_extended', *args)


class RootWorkflowThermal_tuneSignalNew_frequency_list(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.new_frequency_list'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_frequency_list.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_frequency_list.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_frequency_list.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_frequency_list.connect_extended', *args)


class RootWorkflowThermal_tuneSignalNew_fit(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.new_fit'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_fit.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_fit.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_fit.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_fit.connect_extended', *args)


class RootWorkflowThermal_tuneSignalEnded(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.ended'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.ended.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.ended.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.ended.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.ended.connect_extended', *args)


class RootWorkflowThermal_tuneSignalNew_average(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.new_average'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_average.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_average.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_average.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.new_average.connect_extended', *args)


class RootWorkflowThermal_tuneSignalCurrent_calibration_changed(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.current_calibration_changed'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.current_calibration_changed.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.current_calibration_changed.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.current_calibration_changed.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.current_calibration_changed.connect_extended', *args)


class RootWorkflowThermal_tuneSignalProgress(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.progress'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.progress.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.progress.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.progress.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.progress.connect_extended', *args)


class RootWorkflowThermal_tuneSignalData_invalidated(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal.data_invalidated'

    def empty(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.data_invalidated.empty', *args)

    def connect(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.data_invalidated.connect', *args)

    def call(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.data_invalidated.call', *args)

    def connect_extended(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.signal.data_invalidated.connect_extended', *args)


class RootWorkflowThermal_tuneSignal(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune.signal'
        self.data_invalidated = RootWorkflowThermal_tuneSignalData_invalidated(self._context)
        self.progress = RootWorkflowThermal_tuneSignalProgress(self._context)
        self.current_calibration_changed = RootWorkflowThermal_tuneSignalCurrent_calibration_changed(self._context)
        self.new_average = RootWorkflowThermal_tuneSignalNew_average(self._context)
        self.ended = RootWorkflowThermal_tuneSignalEnded(self._context)
        self.new_fit = RootWorkflowThermal_tuneSignalNew_fit(self._context)
        self.new_frequency_list = RootWorkflowThermal_tuneSignalNew_frequency_list(self._context)
        self.started = RootWorkflowThermal_tuneSignalStarted(self._context)
        self.procedure_info = RootWorkflowThermal_tuneSignalProcedure_info(self._context)
        self.new_calibration_data = RootWorkflowThermal_tuneSignalNew_calibration_data(self._context)


class RootWorkflowThermal_tune(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.thermal_tune'
        self.signal = RootWorkflowThermal_tuneSignal(self._context)
        self.property = RootWorkflowThermal_tuneProperty(self._context)

    def current_calibration(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.current_calibration', *args)

    def start(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.start', *args)

    def refit(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.refit', *args)

    def wait_for_async_tasks_to_finish(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.wait_for_async_tasks_to_finish', *args)

    def apply(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.apply', *args)

    def abort(self, *args) -> Any:
        return self._context.call('root.workflow.thermal_tune.abort', *args)


class RootWorkflowWorkspace(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow.workspace'

    def active_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.active_item_id', *args)

    def get_item_position_y(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_position_y', *args)

    def set_item_transparency(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_transparency', *args)

    def get_item_position_x(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_position_x', *args)

    def item_count(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_count', *args)

    def item_exists(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_exists', *args)

    def set_item_rotation(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_rotation', *args)

    def add_point(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_point', *args)

    def delete_all_items(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.delete_all_items', *args)

    def all_item_ids_in_layer(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.all_item_ids_in_layer', *args)

    def item_id_by_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_id_by_name', *args)

    def selected_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.selected_item_id', *args)

    def set_item_visible(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_visible', *args)

    def get_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.get_item_name', *args)

    def set_item_resolution(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_resolution', *args)

    def set_item_position(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_position', *args)

    def set_item_size(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_size', *args)

    def add_frame(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_frame', *args)

    def set_item_name(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.set_item_name', *args)

    def item_name_exists(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.item_name_exists', *args)

    def add_grid(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.add_grid', *args)

    def delete_item(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.delete_item', *args)

    def all_item_ids(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.all_item_ids', *args)

    def default_afm_item_id(self, *args) -> Any:
        return self._context.call('root.workflow.workspace.default_afm_item_id', *args)


class RootWorkflow(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root.workflow'
        self.workspace = RootWorkflowWorkspace(self._context)
        self.thermal_tune = RootWorkflowThermal_tune(self._context)
        self.dynamic = RootWorkflowDynamic(self._context)
        self.approach_motors = RootWorkflowApproach_motors(self._context)
        self.z_controller = RootWorkflowZ_controller(self._context)
        self.xy_closed_loop = RootWorkflowXy_closed_loop(self._context)
        self.frequency_sweep = RootWorkflowFrequency_sweep(self._context)
        self.parameters = RootWorkflowParameters(self._context)
        self.workflow_options = RootWorkflowWorkflow_options(self._context)
        self.workflow_monitoring = RootWorkflowWorkflow_monitoring(self._context)
        self.spm_resource_requester = RootWorkflowSpm_resource_requester(self._context)
        self.workflow_auto_setup = RootWorkflowWorkflow_auto_setup(self._context)
        self.system_startup = RootWorkflowSystem_startup(self._context)
        self.spectroscopy_view = RootWorkflowSpectroscopy_view(self._context)
        self.workflow_spectroscopy_setup = RootWorkflowWorkflow_spectroscopy_setup(self._context)
        self.shared_data_cache = RootWorkflowShared_data_cache(self._context)
        self.spectroscopy = RootWorkflowSpectroscopy(self._context)
        self.comp_dc = RootWorkflowComp_dc(self._context)
        self.manager = RootWorkflowManager(self._context)
        self.ort = RootWorkflowOrt(self._context)
        self.approach = RootWorkflowApproach(self._context)
        self.mode_loader = RootWorkflowMode_loader(self._context)
        self.imaging = RootWorkflowImaging(self._context)
        self.signal_selection = RootWorkflowSignal_selection(self._context)
        self.storage = RootWorkflowStorage(self._context)
        self.laser_align = RootWorkflowLaser_align(self._context)
        self.oscilloscope = RootWorkflowOscilloscope(self._context)
        self.camera_properties = RootWorkflowCamera_properties(self._context)
        self.automation = RootWorkflowAutomation(self._context)
        self.cantilever = RootWorkflowCantilever(self._context)


class Root(wrap.CmdTreeNode):
    def __init__(self, context: 'StudioScriptContext'):
        super().__init__()
        self._context = context
        self._lua_tree_name = 'root'
        self.workflow = RootWorkflow(self._context)
        self.lu = RootLu(self._context)
        self.core = RootCore(self._context)
        self.session = RootSession(self._context)
        self.util = RootUtil(self._context)
        self.test = RootTest(self._context)

    def log_fatal(self, *args) -> Any:
        return self._context.call('root.log_fatal', *args)

    @property
    def init_complete(self) -> bool:
        return bool(self._context.get('root.init_complete'))

    @init_complete.setter
    def init_complete(self, new_val:bool):
        self._context.set('root.init_complete', bool(new_val))

    def log_debug(self, *args) -> Any:
        return self._context.call('root.log_debug', *args)

    def log_info(self, *args) -> Any:
        return self._context.call('root.log_info', *args)

    def log_warn(self, *args) -> Any:
        return self._context.call('root.log_warn', *args)

    def log_error(self, *args) -> Any:
        return self._context.call('root.log_error', *args)


